itkMacro.h

Go to the documentation of this file.

/*=========================================================================
 *
 *  Copyright NumFOCUS
 *
 *  Licensed under the Apache License, Version 2.0 (the "License");
 *  you may not use this file except in compliance with the License.
 *  You may obtain a copy of the License at
 *
 *         https://www.apache.org/licenses/LICENSE-2.0.txt
 *
 *  Unless required by applicable law or agreed to in writing, software
 *  distributed under the License is distributed on an "AS IS" BASIS,
 *  WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
 *  See the License for the specific language governing permissions and
 *  limitations under the License.
 *
 *=========================================================================*/
/*=========================================================================
 *
 *  Portions of this file are subject to the VTK Toolkit Version 3 copyright.
 *
 *  Copyright (c) Ken Martin, Will Schroeder, Bill Lorensen
 *
 *  For complete copyright, license and disclaimer of warranty information
 *  please refer to the NOTICE file at the top of the ITK source tree.
 *
 *=========================================================================*/
 
#ifndef itkMacro_h
#define itkMacro_h
 
#include "itkWin32Header.h"
#include "itkConfigure.h"
#include "ITKCommonExport.h"
 
#include <typeinfo>
 
#include <string>
#include <cstdlib>
#ifndef NDEBUG
#  include <cassert>
#endif
 
#include <sstream>
#include <type_traits> // For is_same, remove_const, and remove_reference.

namespace itk
{
// end namespace itk - this is here for documentation purposes
}

#define itkNotUsed(x)
 
// clang-format off
#define ITK_NOOP_STATEMENT static_assert(true, "")
 
/* NOTE:  The ITK_MACROEND_NOOP_STATEMENT is used at the end
 * of ITK supported macros to ensure that when the macro
 * is used in the code base that the line must have ';' after
 * the macro is used. This makes formatting visually similar
 * to functions, and greatly improves the clang-format
 * behaviors for indentation.  This also assists
 * modern IDE's and removes 1000's of warnings about
 * unused statements or unnecessary ';' when macros are
 * used. */
#define ITK_MACROEND_NOOP_STATEMENT ITK_NOOP_STATEMENT
// clang-format on
 
// Define ITK_PRAGMA macro.
//
// It sets "#pragma" preprocessor directives without expecting the arguments
// to be quoted.
#define ITK_PRAGMA(x) _Pragma(#x)
 
// The GCC/Clang compilers have many useful non-default compiler warnings
// that tend to have a high false positive rate or are otherwise not always appropriate.
// The following set of defines allows us to suppress instances of said warnings.
 
// For GCC and Clang (Clang also identifies itself as GCC, and supports these pragmas):
#if defined(__GNUC__)
#  define ITK_GCC_PRAGMA_PUSH ITK_PRAGMA(GCC diagnostic push)
#  define ITK_GCC_PRAGMA_POP ITK_PRAGMA(GCC diagnostic pop)
#  define ITK_GCC_SUPPRESS_Wfloat_equal ITK_PRAGMA(GCC diagnostic ignored "-Wfloat-equal")
#  define ITK_GCC_SUPPRESS_Wformat_nonliteral ITK_PRAGMA(GCC diagnostic ignored "-Wformat-nonliteral")
#  define ITK_GCC_SUPPRESS_Warray_bounds ITK_PRAGMA(GCC diagnostic ignored "-Warray-bounds")
#else
#  define ITK_GCC_PRAGMA_PUSH
#  define ITK_GCC_PRAGMA_POP
#  define ITK_GCC_SUPPRESS_Wfloat_equal
#  define ITK_GCC_SUPPRESS_Wformat_nonliteral
#  define ITK_GCC_SUPPRESS_Warray_bounds
#endif
 
// -Wmaybe-uninitialized is a real-GCC-only warning name; Apple Clang emits
// -Wunknown-warning-option for it (which ITK's dashboard treats as fatal).
#if defined(__GNUC__) && !defined(__clang__)
#  define ITK_GCC_SUPPRESS_Wmaybe_uninitialized ITK_PRAGMA(GCC diagnostic ignored "-Wmaybe-uninitialized")
#else
#  define ITK_GCC_SUPPRESS_Wmaybe_uninitialized
#endif
 
// For Clang only (and not GCC):
#if defined(__clang__) && defined(__has_warning)
#  define ITK_CLANG_PRAGMA_PUSH ITK_PRAGMA(clang diagnostic push)
#  define ITK_CLANG_PRAGMA_POP ITK_PRAGMA(clang diagnostic pop)
#  if __has_warning("-Wzero-as-null-pointer-constant")
#    define ITK_CLANG_SUPPRESS_Wzero_as_null_pointer_constant \
      ITK_PRAGMA(clang diagnostic ignored "-Wzero-as-null-pointer-constant")
#  else
#    define ITK_CLANG_SUPPRESS_Wzero_as_null_pointer_constant
#  endif
#  if __has_warning("-Wduplicate-enum")
#    define ITK_CLANG_SUPPRESS_Wduplicate_enum ITK_PRAGMA(clang diagnostic ignored "-Wduplicate-enum")
#  else
#    define ITK_CLANG_SUPPRESS_Wduplicate_enum
#  endif
#else
#  define ITK_CLANG_PRAGMA_PUSH
#  define ITK_CLANG_PRAGMA_POP
#  define ITK_CLANG_SUPPRESS_Wzero_as_null_pointer_constant
#  define ITK_CLANG_SUPPRESS_Wduplicate_enum
#endif
 
// These were not intended as public API, but some code was nevertheless using them.
// Support the pre ITK 5.4 spelling for compatibility.
#define CLANG_PRAGMA_PUSH ITK_CLANG_PRAGMA_PUSH
#define CLANG_PRAGMA_POP ITK_CLANG_PRAGMA_POP
#define CLANG_SUPPRESS_Wfloat_equal ITK_GCC_SUPPRESS_Wfloat_equal
 
// For GCC/Clang, to decorate printf-like functions allowing for compiler checks of format strings.
#if defined(__GNUC__)
#  define ITK_FORMAT_PRINTF(a, b) __attribute__((format(printf, a, b)))
#else
#  define ITK_FORMAT_PRINTF(a, b)
#endif
 
#if !defined(ITK_LEGACY_REMOVE)
// Issue warning if deprecated preprocessor flag is used.
#  define CLANG_SUPPRESS_Wcpp14_extensions                                                                \
    [[deprecated("Remove deprecated CLANG_SUPPRESS_Wcpp14_extensions c++14 warning suppression")]] void * \
      CLANG_SUPPRESS_Wcpp14_extensions = nullptr;
#endif
 
// Define ITK_GCC_PRAGMA_DIAG(param1 [param2 [...]]) macro.
//
// This macro sets a pragma diagnostic
//
// Define ITK_GCC_PRAGMA_DIAG_(PUSH|POP) macros.
//
// These macros respectively push and pop the diagnostic context
//
#if defined(__GNUC__)
#  define ITK_GCC_PRAGMA_DIAG(x) ITK_PRAGMA(GCC diagnostic x)
#  define ITK_GCC_PRAGMA_DIAG_PUSH() ITK_GCC_PRAGMA_DIAG(push)
#  define ITK_GCC_PRAGMA_DIAG_POP() ITK_GCC_PRAGMA_DIAG(pop)
#else
#  define ITK_GCC_PRAGMA_DIAG(x)
#  define ITK_GCC_PRAGMA_DIAG_PUSH()
#  define ITK_GCC_PRAGMA_DIAG_POP()
#endif
 
/*
 * ITK only supports MSVC++ 14.2 and greater
 * MSVC++ 14.2 _MSC_VER == 1920 (Visual Studio 2019 Version 16.0)
 */
#if defined(_MSC_VER) && (_MSC_VER < 1920)
#  error "MSVC versions before Visual Studio 2019 are not supported"
#endif
#if defined(__SUNPRO_CC) && (__SUNPRO_CC < 0x5140)
#  error "SUNPro C++ < 5.14.0 is not supported"
#endif
#if defined(__CYGWIN__)
#  error "The Cygwin compiler is not supported"
#endif
#if defined(__BORLANDC__)
#  error "The Borland C compiler is not supported"
#endif
#if defined(__MWERKS__)
#  error "The MetroWerks compiler is not supported"
#endif
#if defined(__GNUC__) && !defined(__clang__) && (__GNUC__ < 7)
#  error "GCC < 7 is not supported"
#endif
#if defined(__sgi)
// This is true for IRIX 6.5.18m with MIPSPro 7.3.1.3m.
// TODO: At some future point, it may be necessary to
// define a minimum __sgi version that will work.
#  error "The SGI compiler is not supported"
#endif
#if defined(__apple_build_version__) && (__apple_build_version__ < 12000032)
#  error "AppleClang < Xcode 12.4 is not supported"
#elif defined(__clang__) && (__clang_major__ < 5)
#  error "Clang < 5 is not supported"
#endif
 
// Setup symbol exports
#if defined(_WIN32) || defined(WIN32)
#  define ITK_ABI_IMPORT __declspec(dllimport)
#  define ITK_ABI_EXPORT __declspec(dllexport)
#  define ITK_ABI_HIDDEN
#else
#  ifdef __GNUC__
#    define ITK_ABI_IMPORT __attribute__((visibility("default")))
#    define ITK_ABI_EXPORT __attribute__((visibility("default")))
#    define ITK_ABI_HIDDEN __attribute__((visibility("hidden")))
#  else
#    define ITK_ABI_IMPORT
#    define ITK_ABI_EXPORT
#    define ITK_ABI_HIDDEN
#  endif
#endif
 
// Setup symbol exports
#ifndef ITK_TEMPLATE_EXPORT
#  ifdef ITK_TEMPLATE_VISIBILITY_DEFAULT
#    define ITK_TEMPLATE_EXPORT __attribute__((visibility("default")))
#  else
#    define ITK_TEMPLATE_EXPORT
#  endif
#endif
 
// Setup symbol exports
#ifdef ITK_TEMPLATE_VISIBILITY_DEFAULT
#  define ITK_FORCE_EXPORT_MACRO(moduleName) __attribute__((visibility("default")))
#else
#  define ITK_FORCE_EXPORT_MACRO(moduleName) moduleName##_EXPORT
#endif
 
#ifndef ITK_FORWARD_EXPORT
// If build with shared libraries, on MacOS, if USE_COMPILER_HIDDEN_VISIBILITY is ON
#  if defined(__APPLE__) && defined(ITK_TEMPLATE_VISIBILITY_DEFAULT) && defined(ITK_BUILD_SHARED_LIBS) && \
    defined(USE_COMPILER_HIDDEN_VISIBILITY)
#    define ITK_FORWARD_EXPORT __attribute__((visibility("default")))
#  else
#    define ITK_FORWARD_EXPORT
#  endif
#endif
 

#define itkNewMacro(x)      \
  itkSimpleNewMacro(x);     \
  itkCreateAnotherMacro(x); \
  itkCloneMacro(x);         \
  ITK_MACROEND_NOOP_STATEMENT
#define itkSimpleNewMacro(x)                              \
  static Pointer New()                                    \
  {                                                       \
    Pointer smartPtr = ::itk::ObjectFactory<x>::Create(); \
    if (smartPtr == nullptr)                              \
    {                                                     \
      smartPtr = new x();                                 \
    }                                                     \
    smartPtr->UnRegister();                               \
    return smartPtr;                                      \
  }                                                       \
  ITK_MACROEND_NOOP_STATEMENT
 
#define itkCreateAnotherMacro(x)                                                               \
  ::itk::LightObject::Pointer CreateAnother() const override { return x::New().GetPointer(); } \
  ITK_MACROEND_NOOP_STATEMENT
 
#define itkCloneMacro(x)                                                  \
  Pointer Clone() const                                                   \
  {                                                                       \
    Pointer rval = dynamic_cast<x *>(this->InternalClone().GetPointer()); \
    return rval;                                                          \
  }                                                                       \
  ITK_MACROEND_NOOP_STATEMENT

#define itkFactoryOnlyNewMacro(x)  \
  itkSimpleFactoryOnlyNewMacro(x); \
  itkCreateAnotherMacro(x);        \
  itkCloneMacro(x);                \
  ITK_MACROEND_NOOP_STATEMENT
#define itkSimpleFactoryOnlyNewMacro(x)                                                                 \
  static auto New() -> Pointer                                                                          \
  {                                                                                                     \
    Pointer smartPtr = ::itk::ObjectFactory<x>::Create();                                               \
    if (smartPtr == nullptr)                                                                            \
    {                                                                                                   \
      itkSpecializedMessageExceptionMacro(ExceptionObject,                                              \
                                          "Object factory failed to instantiate " << typeid(x).name()); \
    }                                                                                                   \
    smartPtr->UnRegister();                                                                             \
    return smartPtr;                                                                                    \
  }                                                                                                     \
  ITK_MACROEND_NOOP_STATEMENT

#define itkFactorylessNewMacro(x) \
  static Pointer New()            \
  {                               \
    auto *  rawPtr = new x();     \
    Pointer smartPtr = rawPtr;    \
    rawPtr->UnRegister();         \
    return smartPtr;              \
  }                               \
  itkCreateAnotherMacro(x);       \
  ITK_MACROEND_NOOP_STATEMENT
//
// A macro to disallow the copy constructor, copy assignment,
// move constructor, and move assignment functions.
// This should be used in the public: declarations for a class
//
// ITK's paradigm for smart pointer and pipeline consistency
// prohibits the use of copy/move construction and copy/move assignment
// functions.
//
#define ITK_DISALLOW_COPY_AND_MOVE(TypeName)       \
  TypeName(const TypeName &) = delete;             \
  TypeName & operator=(const TypeName &) = delete; \
  TypeName(TypeName &&) = delete;                  \
  TypeName & operator=(TypeName &&) = delete
 
#if !defined(ITK_LEGACY_REMOVE)
#  define ITK_DISALLOW_COPY_AND_ASSIGN(TypeName) ITK_DISALLOW_COPY_AND_MOVE(TypeName)
#else
#  define ITK_DISALLOW_COPY_AND_ASSIGN(TypeName) \
    static_assert(false, "Replace deprecated ITK_DISALLOW_COPY_AND_ASSIGN with modern ITK_DISALLOW_COPY_AND_MOVE")
#endif
 

#define ITK_DEFAULT_COPY_AND_MOVE(TypeName)         \
  TypeName(const TypeName &) = default;             \
  TypeName & operator=(const TypeName &) = default; \
  TypeName(TypeName &&) = default;                  \
  TypeName & operator=(TypeName &&) = default
 
// When ITK_EXPERIMENTAL_CXX20_REWRITTEN_UNEQUAL_OPERATOR is defined, ITK uses
// the ability for operator!= to be rewritten automatically in terms of
// operator==, as introduced with C++20. This macro is experimental. It may be
// modified, renamed, or removed without backward compatibility support.
#if __cplusplus >= 202002L
#  define ITK_EXPERIMENTAL_CXX20_REWRITTEN_UNEQUAL_OPERATOR
#endif
 
// Note: The following macro, ITK_UNEQUAL_OPERATOR_MEMBER_FUNCTION(TypeName),
// is only for internal use within the implementation of ITK. It may be
// modified, renamed, or removed without backward compatibility support.
#ifdef ITK_EXPERIMENTAL_CXX20_REWRITTEN_UNEQUAL_OPERATOR
// With C++20, operator!= is automatically rewritten in terms of the
// corresponding operator==.
#  define ITK_UNEQUAL_OPERATOR_MEMBER_FUNCTION(TypeName) ITK_MACROEND_NOOP_STATEMENT
#else
// For C++14 and C++17, this macro defines an operator!= member function that
// just calls the corresponding operator== member function.
#  define ITK_UNEQUAL_OPERATOR_MEMBER_FUNCTION(TypeName)                                 \
    bool operator!=(const TypeName & other) const { return !(this->operator==(other)); } \
    ITK_MACROEND_NOOP_STATEMENT
#endif
 
 
// Internal macro (not part of the public ITK API), used to implement `GetNameOfClass()` member functions.
#define itkInternalGetNameOfClassImplementationMacro(thisClass)                                             \
  {                                                                                                         \
    static_assert(std::is_same_v<thisClass, std::remove_const_t<std::remove_reference_t<decltype(*this)>>>, \
                  "The macro argument `" #thisClass                                                         \
                  "` appears incorrect! It should correspond with the name of this class!");                \
    return #thisClass;                                                                                      \
  }                                                                                                         \
  ITK_MACROEND_NOOP_STATEMENT
 

#define itkVirtualGetNameOfClassMacro(thisClass) \
  virtual const char * GetNameOfClass() const itkInternalGetNameOfClassImplementationMacro(thisClass)
 
#define itkOverrideGetNameOfClassMacro(thisClass) \
  const char * GetNameOfClass() const override itkInternalGetNameOfClassImplementationMacro(thisClass)
 
#ifdef ITK_FUTURE_LEGACY_REMOVE
#  define itkTypeMacro(thisClass, superclass)                                                                      \
    static_assert(false,                                                                                           \
                  "In a future revision of ITK, the macro `itkTypeMacro(thisClass, superclass)` will be removed. " \
                  "Please call `itkOverrideGetNameOfClassMacro(thisClass)` instead!")
#  define itkTypeMacroNoParent(thisClass)                                                                      \
    static_assert(false,                                                                                       \
                  "In a future revision of ITK, the macro `itkTypeMacroNoParent(thisClass)` will be removed. " \
                  "Please call `itkVirtualGetNameOfClassMacro(thisClass)` instead!")
#else
#  define itkTypeMacro(thisClass, superclass) itkOverrideGetNameOfClassMacro(thisClass)
#  define itkTypeMacroNoParent(thisClass) itkVirtualGetNameOfClassMacro(thisClass)
#endif
 
 
namespace itk
{
#ifndef ITK_FUTURE_LEGACY_REMOVE
extern ITKCommon_EXPORT void
OutputWindowDisplayText(const char *);
 
extern ITKCommon_EXPORT void
OutputWindowDisplayErrorText(const char *);
 
extern ITKCommon_EXPORT void
OutputWindowDisplayWarningText(const char *);
 
extern ITKCommon_EXPORT void
OutputWindowDisplayGenericOutputText(const char *);
 
extern ITKCommon_EXPORT void
OutputWindowDisplayDebugText(const char *);
#endif
 
// New context-aware versions of output display functions
extern ITKCommon_EXPORT void
OutputWindowDisplayDebugText(const char * file,
                             unsigned int line,
                             const char * className,
                             const void * objectAddress,
                             const char * message);
 
extern ITKCommon_EXPORT void
OutputWindowDisplayWarningText(const char * file,
                               unsigned int line,
                               const char * className,
                               const void * objectAddress,
                               const char * message);
 
extern ITKCommon_EXPORT void
OutputWindowDisplayErrorText(const char * file,
                             unsigned int line,
                             const char * className,
                             const void * objectAddress,
                             const char * message);
 
extern ITKCommon_EXPORT void
OutputWindowDisplayGenericOutputText(const char * file, unsigned int line, const char * message);
 
} // end namespace itk
 
// The itkDebugStatement is to be used to protect code that is only used in the itkDebugMacro
#if defined(NDEBUG)
#  define itkDebugMacro(x) ITK_NOOP_STATEMENT
#  define itkDebugStatement(x) ITK_NOOP_STATEMENT
#else
#  define itkDebugMacro(x)                                                                                           \
    {                                                                                                                \
      using namespace ::itk::print_helper; /* for ostream << std::vector<T> */                                       \
      if (this->GetDebug() && ::itk::Object::GetGlobalWarningDisplay())                                              \
      {                                                                                                              \
        std::ostringstream itkmsg;                                                                                   \
        itkmsg << "" x;                                                                                              \
        ::itk::OutputWindowDisplayDebugText(__FILE__, __LINE__, this->GetNameOfClass(), this, itkmsg.str().c_str()); \
      }                                                                                                              \
    }                                                                                                                \
    ITK_MACROEND_NOOP_STATEMENT
// The itkDebugStatement is to be used to protect code that is only
// used in the itkDebugMacro
#  define itkDebugStatement(x) x
#endif
#define itkWarningMacro(x)                                                                                           \
  {                                                                                                                  \
    if (::itk::Object::GetGlobalWarningDisplay())                                                                    \
    {                                                                                                                \
      std::ostringstream itkmsg;                                                                                     \
      itkmsg << "" x;                                                                                                \
      ::itk::OutputWindowDisplayWarningText(__FILE__, __LINE__, this->GetNameOfClass(), this, itkmsg.str().c_str()); \
    }                                                                                                                \
  }                                                                                                                  \
  ITK_MACROEND_NOOP_STATEMENT
 
 
#define itkWarningStatement(x) x
 
#if defined(ITK_CPP_FUNCTION)
#  if defined(_WIN32) && !defined(__MINGW32__) && !defined(ITK_WRAPPING_PARSER)
#    define ITK_LOCATION __FUNCSIG__
#  elif defined(__GNUC__)
#    define ITK_LOCATION __PRETTY_FUNCTION__
#  else
#    define ITK_LOCATION __FUNCTION__
#  endif
#else
#  define ITK_LOCATION "unknown"
#endif
 
#define itkDeclareExceptionMacro(newexcp, parentexcp, whatmessage)                   \
  namespace itk                                                                      \
  {                                                                                  \
  class newexcp : public parentexcp                                                  \
  {                                                                                  \
  public:                                                                            \
    /* default message provides backward compatibility for a given exception type */ \
    static constexpr const char * const default_exception_message = whatmessage;     \
    /* Inherit the constructors from its base class. */                              \
    using parentexcp::parentexcp;                                                    \
    itkOverrideGetNameOfClassMacro(newexcp);                                         \
  };                                                                                 \
  }                                                                                  \
  ITK_MACROEND_NOOP_STATEMENT
 
 
#define itkSpecializedMessageExceptionMacro(ExceptionType, x)                                                        \
  {                                                                                                                  \
    std::ostringstream exceptionDescriptionOutputStringStream;                                                       \
    exceptionDescriptionOutputStringStream << "" x;                                                                  \
    throw ::itk::ExceptionType(                                                                                      \
      std::string{ __FILE__ }, __LINE__, exceptionDescriptionOutputStringStream.str(), std::string{ ITK_LOCATION }); \
  }                                                                                                                  \
  ITK_MACROEND_NOOP_STATEMENT
 
#define itkSpecializedExceptionMacro(ExceptionType) \
  throw ::itk::ExceptionType(                       \
    std::string{ __FILE__ }, __LINE__, ::itk::ExceptionType::default_exception_message, std::string{ ITK_LOCATION });
 

#define itkExceptionMacro(x)                                                   \
  {                                                                            \
    std::ostringstream exceptionDescriptionOutputStringStream;                 \
    exceptionDescriptionOutputStringStream << "" x;                            \
    throw ::itk::ExceptionObject(std::string{ __FILE__ },                      \
                                 __LINE__,                                     \
                                 exceptionDescriptionOutputStringStream.str(), \
                                 std::string{ ITK_LOCATION },                  \
                                 this);                                        \
  }                                                                            \
  ITK_MACROEND_NOOP_STATEMENT
 
#define itkExceptionStringMacro(x)                                                             \
  {                                                                                            \
    throw ::itk::ExceptionObject(                                                              \
      std::string{ __FILE__ }, __LINE__, std::string{ x }, std::string{ ITK_LOCATION }, this); \
  }                                                                                            \
  ITK_MACROEND_NOOP_STATEMENT
 
#define itkGenericExceptionMacro(x) itkSpecializedMessageExceptionMacro(ExceptionObject, x)
 
#define itkGenericOutputMacro(x)                                                             \
  {                                                                                          \
    if (::itk::Object::GetGlobalWarningDisplay())                                            \
    {                                                                                        \
      std::ostringstream itkmsg;                                                             \
      itkmsg << "" x;                                                                        \
      ::itk::OutputWindowDisplayGenericOutputText(__FILE__, __LINE__, itkmsg.str().c_str()); \
    }                                                                                        \
  }                                                                                          \
  ITK_MACROEND_NOOP_STATEMENT
 
//----------------------------------------------------------------------------
// Macros for simplifying the use of logging
//
#define itkLogMacro(x, y)                                \
  {                                                      \
    if (this->GetLogger())                               \
    {                                                    \
      this->GetLogger()->Write(::itk::LoggerBase::x, y); \
    }                                                    \
  }                                                      \
  ITK_MACROEND_NOOP_STATEMENT
 
#define itkLogMacroStatic(obj, x, y)                    \
  {                                                     \
    if (obj->GetLogger())                               \
    {                                                   \
      obj->GetLogger()->Write(::itk::LoggerBase::x, y); \
    }                                                   \
  }                                                     \
  ITK_MACROEND_NOOP_STATEMENT
 
//----------------------------------------------------------------------------
// Setup legacy code policy.
//
// CMake options:
//  - When ITK_LEGACY_REMOVE:BOOL=ON, legacy code is hidden, thus causing compiler errors for code that depends on it
//  - When ITK_LEGACY_REMOVE:BOOL=OFF, and ITK_LEGACY_SILENT:BOOL=ON, use
//    of legacy code will not produce compiler warnings.
//  - When ITK_LEGACY_REMOVE:BOOL=OFF, and ITK_LEGACY_SILENT:BOOL=OFF, use
//    of legacy code will produce compiler warnings
//
// ITK_LEGACY_SILENT silently use legacy code. The default is to warn about legacy code use.
//
// Source files that test the legacy code may define ITK_LEGACY_TEST
// like this:
//
//  #define ITK_LEGACY_TEST
//  #include "itkClassWithDeprecatedMethod.h"
//
// in order to silence the warnings for calling deprecated methods.
// No other source files in ITK should call the methods since they are
// provided only for compatibility with older user code.
 
// Define itkLegacyMacro to mark legacy methods where they are
// declared in their class.  Example usage:
//
//   // \deprecated Replaced by MyOtherMethod() as of ITK 2.0.
//   itkLegacyMacro(void MyMethod();)
//
// See below for what to do for the method definition.
#if defined(ITK_LEGACY_REMOVE)
#  define itkLegacyMacro(method) /* no ';' */
#else
#  if defined(ITK_LEGACY_SILENT) || defined(ITK_LEGACY_TEST)
//   Provide legacy methods with no warnings.
#    define itkLegacyMacro(method) method /* no ';' */
#  else
//   Request compile-time warnings for uses of deprecated methods.
#    define itkLegacyMacro(method) [[deprecated]] method /* no ';' */
#  endif
#endif
 
// Macros to create runtime deprecation warning messages in function
// bodies.  Example usage:
//
//   #if !defined( ITK_LEGACY_REMOVE )
//   void itkMyClass::MyOldMethod()
//     {
//     itkLegacyBodyMacro(itkMyClass::MyOldMethod, 2.0);
//     }
//
//   void itkMyClass::MyMethod()
//     {
//     itkLegacyReplaceBodyMacro(itkMyClass::MyMethod, 2.0,
//                               itkMyClass::MyOtherMethod);
//     }
//   #endif
//
//   NOTE: These 4 macros itkLegacyBodyMacro, itkLegacyReplaceBodyMacro,
//         itkGenericLegacyBodyMacro, and itkGenericLegacyReplaceBodyMacro
//         are purposefully not defined when ITK_LEGACY_REMOVE is on,
//         because these macros are only relevant inside code segments
//         that are conditionally compiled only when ITK_LEGACY_REMOVE
//         is off.
#if defined(ITK_LEGACY_SILENT)
#  define itkLegacyBodyMacro(method, version) ITK_NOOP_STATEMENT
#  define itkLegacyReplaceBodyMacro(method, version, replace) ITK_NOOP_STATEMENT
#  define itkGenericLegacyBodyMacro(method, version) ITK_NOOP_STATEMENT
#  define itkGenericLegacyReplaceBodyMacro(method, version, replace) ITK_NOOP_STATEMENT
#else
#  define itkLegacyBodyMacro(method, version) \
    itkWarningMacro(#method " was deprecated for ITK " #version " and will be removed in a future version.")
#  define itkLegacyReplaceBodyMacro(method, version, replace)   \
    itkWarningMacro(#method " was deprecated for ITK " #version \
                            " and will be removed in a future version.  Use " #replace " instead.")
#  define itkGenericLegacyBodyMacro(method, version) \
    itkGenericOutputMacro(#method " was deprecated for ITK " #version " and will be removed in a future version.")
#  define itkGenericLegacyReplaceBodyMacro(method, version, replace)  \
    itkGenericOutputMacro(#method " was deprecated for ITK " #version \
                                  " and will be removed in a future version.  Use " #replace " instead.")
#endif
 
// Most modern x86 CPUs have 64 byte aligned blocks which are used for
// the cache lines. By aligning multi-threaded structures with the
// cache lines, false shared can be reduced, and performance
// increased.
constexpr size_t ITK_CACHE_LINE_ALIGNMENT{ 64 };
 
//
// itkPadStruct will add padding to a structure to ensure a minimum size
// for ensuring that adjacent structures do not share CACHE lines.
// Each struct will take up some multiple of cacheline sizes.
// This is particularly useful for arrays of thread private variables.
//
#define itkPadStruct(mincachesize, oldtype, newtype)                      \
  struct newtype : public oldtype                                         \
  {                                                                       \
    char _StructPadding[mincachesize - (sizeof(oldtype) % mincachesize)]; \
  }
 
//
// itkAlignedTypedef is a macro which creates a new type to make a
// data structure aligned.
//
#if defined(ITK_HAS_GNU_ATTRIBUTE_ALIGNED)
#  define itkAlignedTypedef(alignment, oldtype, newtype) using newtype = oldtype __attribute__((aligned(alignment)))
#elif defined(_MSC_VER)
#  define itkAlignedTypedef(alignment, oldtype, newtype) using newtype = __declspec(align(alignment)) oldtype
#else
#  define itkAlignedTypedef(alignment, oldtype, newtype) using newtype = oldtype
#endif
 
#if defined(ITK_FUTURE_LEGACY_REMOVE)
//=============================================================================
/*
NOTE: DEPRECATED - This macro is not longer needed to support modern
compilers.
 
 Define a common way of declaring a templated function as a friend inside a class.
  - ITK_FRIEND_TEMPLATE_FUNCTION_ARGUMENTS(T)
 
  The following templated function
 
            template <T>
            T add(const T & a, const T & b);
 
   is declared as friend with
 
            class A
              {
              public:
                friend Self add<>( const Self & a, const Self & b );
              }
 
*/
#  define ITK_FRIEND_TEMPLATE_FUNCTION_ARGUMENT(T) < >
#else // LEGACY_REMOVE
#  define ITK_FRIEND_TEMPLATE_FUNCTION_ARGUMENT(T) "Macro remove use C++11 compliant declaration of "
#endif
 
//--------------------------------------------------------------------------------
//  Helper macros for Template Meta-Programming techniques of for-loops
// unrolling
//--------------------------------------------------------------------------------
 
//--------------------------------------------------------------------------------
// Macro that generates an unrolled for loop for assigning elements of one array
// to elements of another array The array are assumed to be of same length
// (dimension), and this is also assumed to be the value of NumberOfIterations.
// No verification of size is performed. Casting is performed as part of the
// assignment, by using the DestinationElementType as the casting type.
// Source and destination array types must have defined operator[] in their
// API.
#define itkForLoopAssignmentMacro(                                                                        \
  DestinationType, SourceType, DestinationElementType, DestinationArray, SourceArray, NumberOfIterations) \
  for (unsigned int i = 0; i < NumberOfIterations; ++i)                                                   \
  {                                                                                                       \
    DestinationArray[i] = static_cast<DestinationElementType>(SourceArray[i]);                            \
  }                                                                                                       \
  ITK_MACROEND_NOOP_STATEMENT
 
//--------------------------------------------------------------------------------
// Macro that generates an unrolled for loop for rounding and assigning
// elements of one array to elements of another array The array are assumed to
// be of same length (dimension), and this is also assumed to be the value of
// NumberOfIterations.  No verification of size is performed. Casting is
// performed as part of the assignment, by using the DestinationElementType as
// the casting type.
// Source and destination array types must have defined operator[] in their
// API.
#define itkForLoopRoundingAndAssignmentMacro(                                                                     \
  DestinationType, Sourcrnd_halfintup, DestinationElementType, DestinationArray, SourceArray, NumberOfIterations) \
  for (unsigned int i = 0; i < NumberOfIterations; ++i)                                                           \
  {                                                                                                               \
    DestinationArray[i] = ::itk::Math::Round<DestinationElementType>(SourceArray[i]);                             \
  }                                                                                                               \
  ITK_MACROEND_NOOP_STATEMENT
 
// end of Template Meta Programming helper macros
 
#if !defined(NDEBUG) && !defined(ITK_WRAPPING)
 
#  ifdef __GLIBC__
#    define itkAssertInDebugOrThrowInReleaseMacro(msg) __assert_fail(msg, __FILE__, __LINE__, __ASSERT_FUNCTION);
#  else
#    define itkAssertInDebugOrThrowInReleaseMacro(msg) itkGenericExceptionMacro(<< msg);
#  endif
 
#else
#  define itkAssertInDebugOrThrowInReleaseMacro(msg) itkGenericExceptionMacro(<< msg);
#endif
 
#define itkAssertOrThrowMacro(test, message)                     \
  if (!(test))                                                   \
  {                                                              \
    std::ostringstream msgstr;                                   \
    msgstr << message;                                           \
    itkAssertInDebugOrThrowInReleaseMacro(msgstr.str().c_str()); \
  }                                                              \
  ITK_MACROEND_NOOP_STATEMENT
 
#if !defined(NDEBUG) && !defined(ITK_WRAPPING)
#  define itkAssertInDebugAndIgnoreInReleaseMacro(X) assert(X)
#else
#  define itkAssertInDebugAndIgnoreInReleaseMacro(X) ITK_NOOP_STATEMENT
#endif
 
 
//  !!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!
//  !!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!
//  !!  The ITK Get/Set Macros for various types !!
//  !!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!
//  !!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!
 
#ifdef ITK_FUTURE_LEGACY_REMOVE
#  define itkStaticConstMacro(name, type, value) \
    "Replace itkStaticConstMacro(name, type, value) with `static constexpr type name = value`"
#  define itkGetStaticConstMacro(name) "Replace itkGetStaticConstMacro(name) with `Self::name`"
#else
#  define itkStaticConstMacro(name, type, value) static constexpr type name = value
 
#  define itkGetStaticConstMacro(name) (Self::name)
#endif
 
// Set an input. This defines the Set"name"() method. Implementation detail; use the public wrappers below.
#define ITK_DETAIL_SetInputMacroImpl(virtualKeyword, finalKeyword, name, type)           \
  virtualKeyword void Set##name(const type * _arg) finalKeyword                          \
  {                                                                                      \
    itkDebugMacro("setting input " #name " to " << _arg);                                \
    if (_arg != itkDynamicCastInDebugMode<type *>(this->ProcessObject::GetInput(#name))) \
    {                                                                                    \
      this->ProcessObject::SetInput(#name, const_cast<type *>(_arg));                    \
      this->Modified();                                                                  \
    }                                                                                    \
  }                                                                                      \
  ITK_MACROEND_NOOP_STATEMENT

#define itkVirtualSetInputMacro(name, type) ITK_DETAIL_SetInputMacroImpl(virtual, , name, type)
#define itkFinalSetInputMacro(name, type) ITK_DETAIL_SetInputMacroImpl(, final, name, type)
#define itkNonVirtualSetInputMacro(name, type) ITK_DETAIL_SetInputMacroImpl(, , name, type)
#define itkSetInputMacro(name, type) ITK_DETAIL_SetInputMacroImpl(virtual, , name, type)
 
// Get an input. This defines the Get"name"() method. Implementation detail; use the public wrappers below.
#define ITK_DETAIL_GetInputMacroImpl(virtualKeyword, finalKeyword, name, type)                 \
  virtualKeyword const type * Get##name() const finalKeyword                                   \
  {                                                                                            \
    itkDebugMacro("returning input " << #name " of " << this->ProcessObject::GetInput(#name)); \
    return itkDynamicCastInDebugMode<const type *>(this->ProcessObject::GetInput(#name));      \
  }                                                                                            \
  ITK_MACROEND_NOOP_STATEMENT

#define itkVirtualGetInputMacro(name, type) ITK_DETAIL_GetInputMacroImpl(virtual, , name, type)
#define itkFinalGetInputMacro(name, type) ITK_DETAIL_GetInputMacroImpl(, final, name, type)
#define itkNonVirtualGetInputMacro(name, type) ITK_DETAIL_GetInputMacroImpl(, , name, type)
#define itkGetInputMacro(name, type) ITK_DETAIL_GetInputMacroImpl(virtual, , name, type)
 
// clang-format off
// Set a decorated input. Defines Set"name"Input(), Set"name"(decorator*) and Set"name"(value). Implementation detail; use the public wrappers below.
#define ITK_DETAIL_SetDecoratedInputMacroImpl(virtualKeyword, finalKeyword, name, type)                                            \
  virtualKeyword void Set##name##Input(const SimpleDataObjectDecorator<type> * _arg) finalKeyword                          \
  {                                                                                                                 \
    itkDebugMacro("setting input " #name " to " << _arg);                                                           \
    if (_arg != itkDynamicCastInDebugMode<SimpleDataObjectDecorator<type> *>(this->ProcessObject::GetInput(#name))) \
    {                                                                                                               \
      this->ProcessObject::SetInput(#name, const_cast<SimpleDataObjectDecorator<type> *>(_arg));                    \
      this->Modified();                                                                                             \
    }                                                                                                               \
  }                                                                                                                 \
  virtualKeyword void Set##name(const SimpleDataObjectDecorator<type> * _arg) finalKeyword                                 \
  {                                                                                                                 \
    this->Set##name##Input(_arg);                                                                                   \
  }                                                                                                                 \
  virtualKeyword void Set##name(const type & _arg) finalKeyword                                                            \
  {                                                                                                                 \
    using DecoratorType = SimpleDataObjectDecorator<type>;                                                          \
    itkDebugMacro("setting input " #name " to " << _arg);                                                           \
    const DecoratorType * oldInput =                                                                                \
      itkDynamicCastInDebugMode<const DecoratorType *>(this->ProcessObject::GetInput(#name));                       \
    ITK_GCC_PRAGMA_PUSH                                                                                             \
    ITK_GCC_SUPPRESS_Wfloat_equal                                                                                   \
    if (oldInput && oldInput->Get() == _arg)                                                                        \
    {                                                                                                               \
      return;                                                                                                       \
    }                                                                                                               \
    ITK_GCC_PRAGMA_POP                                                                                              \
    auto newInput = DecoratorType::New();                                                                           \
    newInput->Set(_arg);                                                                                            \
    this->Set##name##Input(newInput);                                                                               \
  }                                                                                                                 \
  ITK_MACROEND_NOOP_STATEMENT
// clang-format on

#define itkVirtualSetDecoratedInputMacro(name, type) ITK_DETAIL_SetDecoratedInputMacroImpl(virtual, , name, type)
#define itkFinalSetDecoratedInputMacro(name, type) ITK_DETAIL_SetDecoratedInputMacroImpl(, final, name, type)
#define itkNonVirtualSetDecoratedInputMacro(name, type) ITK_DETAIL_SetDecoratedInputMacroImpl(, , name, type)
#define itkSetDecoratedInputMacro(name, type) ITK_DETAIL_SetDecoratedInputMacroImpl(virtual, , name, type)
 
// Get a decorated input. Defines Get"name"Input() and Get"name"(). Implementation detail; use the public wrappers
// below.
#define ITK_DETAIL_GetDecoratedInputMacroImpl(virtualKeyword, finalKeyword, name, type)                              \
  virtualKeyword const SimpleDataObjectDecorator<type> * Get##name##Input() const finalKeyword                       \
  {                                                                                                                  \
    itkDebugMacro("returning input " << #name " of " << this->ProcessObject::GetInput(#name));                       \
    return itkDynamicCastInDebugMode<const SimpleDataObjectDecorator<type> *>(this->ProcessObject::GetInput(#name)); \
  }                                                                                                                  \
  virtualKeyword const type & Get##name() const finalKeyword                                                         \
  {                                                                                                                  \
    itkDebugMacro("Getting input " #name);                                                                           \
    using DecoratorType = SimpleDataObjectDecorator<type>;                                                           \
    const DecoratorType * input =                                                                                    \
      itkDynamicCastInDebugMode<const DecoratorType *>(this->ProcessObject::GetInput(#name));                        \
    if (input == nullptr)                                                                                            \
    {                                                                                                                \
      itkExceptionStringMacro("input" #name " is not set");                                                          \
    }                                                                                                                \
    return input->Get();                                                                                             \
  }                                                                                                                  \
  ITK_MACROEND_NOOP_STATEMENT

#define itkVirtualGetDecoratedInputMacro(name, type) ITK_DETAIL_GetDecoratedInputMacroImpl(virtual, , name, type)
#define itkFinalGetDecoratedInputMacro(name, type) ITK_DETAIL_GetDecoratedInputMacroImpl(, final, name, type)
#define itkNonVirtualGetDecoratedInputMacro(name, type) ITK_DETAIL_GetDecoratedInputMacroImpl(, , name, type)
#define itkGetDecoratedInputMacro(name, type) ITK_DETAIL_GetDecoratedInputMacroImpl(virtual, , name, type)

#define itkVirtualSetGetDecoratedInputMacro(name, type) \
  itkVirtualSetDecoratedInputMacro(name, type);         \
  itkVirtualGetDecoratedInputMacro(name, type)
#define itkFinalSetGetDecoratedInputMacro(name, type) \
  itkFinalSetDecoratedInputMacro(name, type);         \
  itkFinalGetDecoratedInputMacro(name, type)
#define itkNonVirtualSetGetDecoratedInputMacro(name, type) \
  itkNonVirtualSetDecoratedInputMacro(name, type);         \
  itkNonVirtualGetDecoratedInputMacro(name, type)
#define itkSetGetDecoratedInputMacro(name, type) \
  itkSetDecoratedInputMacro(name, type);         \
  itkGetDecoratedInputMacro(name, type)
 
// Set a decorated itk::Object-derived (non-DataObject) input. Defines Set"name"() and Set"name"Input().
// Implementation detail; use the public wrappers below.
#define ITK_DETAIL_SetDecoratedObjectInputMacroImpl(virtualKeyword, finalKeyword, name, type)                 \
  virtualKeyword void Set##name##Input(const DataObjectDecorator<type> * _arg) finalKeyword                   \
  {                                                                                                           \
    itkDebugMacro("setting input " #name " to " << _arg);                                                     \
    if (_arg != itkDynamicCastInDebugMode<DataObjectDecorator<type> *>(this->ProcessObject::GetInput(#name))) \
    {                                                                                                         \
      this->ProcessObject::SetInput(#name, const_cast<DataObjectDecorator<type> *>(_arg));                    \
      this->Modified();                                                                                       \
    }                                                                                                         \
  }                                                                                                           \
  virtualKeyword void Set##name(const type * _arg) finalKeyword                                               \
  {                                                                                                           \
    using DecoratorType = DataObjectDecorator<type>;                                                          \
    itkDebugMacro("setting input " #name " to " << _arg);                                                     \
    const DecoratorType * oldInput =                                                                          \
      itkDynamicCastInDebugMode<const DecoratorType *>(this->ProcessObject::GetInput(#name));                 \
    if (oldInput && oldInput->Get() == _arg)                                                                  \
    {                                                                                                         \
      return;                                                                                                 \
    }                                                                                                         \
    auto newInput = DecoratorType::New();                                                                     \
    newInput->Set(_arg);                                                                                      \
    this->Set##name##Input(newInput);                                                                         \
  }                                                                                                           \
  ITK_MACROEND_NOOP_STATEMENT

#define itkVirtualSetDecoratedObjectInputMacro(name, type) \
  ITK_DETAIL_SetDecoratedObjectInputMacroImpl(virtual, , name, type)
#define itkFinalSetDecoratedObjectInputMacro(name, type) \
  ITK_DETAIL_SetDecoratedObjectInputMacroImpl(, final, name, type)
#define itkNonVirtualSetDecoratedObjectInputMacro(name, type) \
  ITK_DETAIL_SetDecoratedObjectInputMacroImpl(, , name, type)
#define itkSetDecoratedObjectInputMacro(name, type) ITK_DETAIL_SetDecoratedObjectInputMacroImpl(virtual, , name, type)
 
// Get a decorated itk::Object-derived (non-DataObject) input. Defines Get"name"() and Get"name"Input().
// Implementation detail; use the public wrappers below.
#define ITK_DETAIL_GetDecoratedObjectInputMacroImpl(virtualKeyword, finalKeyword, name, type)                  \
  virtualKeyword const DataObjectDecorator<type> * Get##name##Input() const finalKeyword                       \
  {                                                                                                            \
    itkDebugMacro("returning input " << #name " of " << this->ProcessObject::GetInput(#name));                 \
    return itkDynamicCastInDebugMode<const DataObjectDecorator<type> *>(this->ProcessObject::GetInput(#name)); \
  }                                                                                                            \
  virtualKeyword const type * Get##name() const finalKeyword                                                   \
  {                                                                                                            \
    itkDebugMacro("Getting input " #name);                                                                     \
    using DecoratorType = DataObjectDecorator<type>;                                                           \
    const DecoratorType * input =                                                                              \
      itkDynamicCastInDebugMode<const DecoratorType *>(this->ProcessObject::GetInput(#name));                  \
    if (input == nullptr)                                                                                      \
    {                                                                                                          \
      return nullptr;                                                                                          \
    }                                                                                                          \
    return input->Get();                                                                                       \
  }                                                                                                            \
  ITK_MACROEND_NOOP_STATEMENT

#define itkVirtualGetDecoratedObjectInputMacro(name, type) \
  ITK_DETAIL_GetDecoratedObjectInputMacroImpl(virtual, , name, type)
#define itkFinalGetDecoratedObjectInputMacro(name, type) \
  ITK_DETAIL_GetDecoratedObjectInputMacroImpl(, final, name, type)
#define itkNonVirtualGetDecoratedObjectInputMacro(name, type) \
  ITK_DETAIL_GetDecoratedObjectInputMacroImpl(, , name, type)
#define itkGetDecoratedObjectInputMacro(name, type) ITK_DETAIL_GetDecoratedObjectInputMacroImpl(virtual, , name, type)

#define itkVirtualSetGetDecoratedObjectInputMacro(name, type) \
  itkVirtualSetDecoratedObjectInputMacro(name, type);         \
  itkVirtualGetDecoratedObjectInputMacro(name, type)
#define itkFinalSetGetDecoratedObjectInputMacro(name, type) \
  itkFinalSetDecoratedObjectInputMacro(name, type);         \
  itkFinalGetDecoratedObjectInputMacro(name, type)
#define itkNonVirtualSetGetDecoratedObjectInputMacro(name, type) \
  itkNonVirtualSetDecoratedObjectInputMacro(name, type);         \
  itkNonVirtualGetDecoratedObjectInputMacro(name, type)
#define itkSetGetDecoratedObjectInputMacro(name, type) \
  itkSetDecoratedObjectInputMacro(name, type);         \
  itkGetDecoratedObjectInputMacro(name, type)
 
// Internal Set/Get macro bodies parametrized by the C++ virtual-specifier
// (`virtual`) and the trailing virt-specifier (`final`); at most one of
// `virtualKeyword`/`finalKeyword` is non-empty. Public variants below:
// itkVirtual*, itkFinal*, itkNonVirtual*; legacy itk*Macro forms remain
// `virtual` for ABI-stability through ITK v7. No `itkOverride*` variants:
// inherit the base member, or write the function by hand when an override
// genuinely needs different behavior. Implementation detail; use the public
// wrappers below.
// clang-format off
// Do not invoke ITK_DETAIL_SetMacroImpl directly from user code; use the public wrappers below.
#define ITK_DETAIL_SetMacroImpl(virtualKeyword, finalKeyword, name, type) \
  virtualKeyword void Set##name(type _arg) finalKeyword          \
  {                                                       \
    itkDebugMacro("setting " #name " to " << _arg);       \
    ITK_GCC_PRAGMA_PUSH                                   \
    ITK_GCC_SUPPRESS_Wfloat_equal                         \
    if (this->m_##name != _arg)                           \
    {                                                     \
      this->m_##name = std::move(_arg);                   \
      this->Modified();                                   \
    }                                                     \
    ITK_GCC_PRAGMA_POP                                    \
  }                                                       \
  ITK_MACROEND_NOOP_STATEMENT
// clang-format on
 
// Do not invoke ITK_DETAIL_GetMacroImpl directly from user code; use the public wrappers below.
#define ITK_DETAIL_GetMacroImpl(virtualKeyword, finalKeyword, name, type) \
  virtualKeyword type Get##name() finalKeyword { return this->m_##name; } \
  ITK_MACROEND_NOOP_STATEMENT
 
// Do not invoke ITK_DETAIL_GetConstMacroImpl directly from user code; use the public wrappers below.
#define ITK_DETAIL_GetConstMacroImpl(virtualKeyword, finalKeyword, name, type)  \
  virtualKeyword type Get##name() const finalKeyword { return this->m_##name; } \
  ITK_MACROEND_NOOP_STATEMENT
 
// Do not invoke ITK_DETAIL_GetConstReferenceMacroImpl directly from user code; use the public wrappers below.
#define ITK_DETAIL_GetConstReferenceMacroImpl(virtualKeyword, finalKeyword, name, type) \
  virtualKeyword const type & Get##name() const finalKeyword { return this->m_##name; } \
  ITK_MACROEND_NOOP_STATEMENT

#define itkVirtualSetMacro(name, type) ITK_DETAIL_SetMacroImpl(virtual, , name, type)
#define itkFinalSetMacro(name, type) ITK_DETAIL_SetMacroImpl(, final, name, type)
#define itkNonVirtualSetMacro(name, type) ITK_DETAIL_SetMacroImpl(, , name, type)
#define itkSetMacro(name, type) ITK_DETAIL_SetMacroImpl(virtual, , name, type)

#define itkVirtualGetMacro(name, type) ITK_DETAIL_GetMacroImpl(virtual, , name, type)
#define itkFinalGetMacro(name, type) ITK_DETAIL_GetMacroImpl(, final, name, type)
#define itkNonVirtualGetMacro(name, type) ITK_DETAIL_GetMacroImpl(, , name, type)
#define itkGetMacro(name, type) ITK_DETAIL_GetMacroImpl(virtual, , name, type)

#define itkVirtualGetConstMacro(name, type) ITK_DETAIL_GetConstMacroImpl(virtual, , name, type)
#define itkFinalGetConstMacro(name, type) ITK_DETAIL_GetConstMacroImpl(, final, name, type)
#define itkNonVirtualGetConstMacro(name, type) ITK_DETAIL_GetConstMacroImpl(, , name, type)
#define itkGetConstMacro(name, type) ITK_DETAIL_GetConstMacroImpl(virtual, , name, type)

#define itkVirtualGetConstReferenceMacro(name, type) ITK_DETAIL_GetConstReferenceMacroImpl(virtual, , name, type)
#define itkFinalGetConstReferenceMacro(name, type) ITK_DETAIL_GetConstReferenceMacroImpl(, final, name, type)
#define itkNonVirtualGetConstReferenceMacro(name, type) ITK_DETAIL_GetConstReferenceMacroImpl(, , name, type)
#define itkGetConstReferenceMacro(name, type) ITK_DETAIL_GetConstReferenceMacroImpl(virtual, , name, type)
// Set an enum-typed member. Creates Set"name"(); avoids itkDebugMacro warnings
// on some compilers with non-specified enum types. Implementation detail; use the public wrappers below.
#define ITK_DETAIL_SetEnumMacroImpl(virtualKeyword, finalKeyword, name, type) \
  virtualKeyword void Set##name(const type _arg) finalKeyword                 \
  {                                                                           \
    itkDebugMacro("setting " #name " to " << static_cast<long>(_arg));        \
    if (this->m_##name != _arg)                                               \
    {                                                                         \
      this->m_##name = _arg;                                                  \
      this->Modified();                                                       \
    }                                                                         \
  }                                                                           \
  ITK_MACROEND_NOOP_STATEMENT

#define itkVirtualSetEnumMacro(name, type) ITK_DETAIL_SetEnumMacroImpl(virtual, , name, type)
#define itkFinalSetEnumMacro(name, type) ITK_DETAIL_SetEnumMacroImpl(, final, name, type)
#define itkNonVirtualSetEnumMacro(name, type) ITK_DETAIL_SetEnumMacroImpl(, , name, type)
#define itkSetEnumMacro(name, type) ITK_DETAIL_SetEnumMacroImpl(virtual, , name, type)
 
// Get an enum-typed member. Creates Get"name"(). Implementation detail; use the public wrappers below.
#define ITK_DETAIL_GetEnumMacroImpl(virtualKeyword, finalKeyword, name, type)   \
  virtualKeyword type Get##name() const finalKeyword { return this->m_##name; } \
  ITK_MACROEND_NOOP_STATEMENT

#define itkVirtualGetEnumMacro(name, type) ITK_DETAIL_GetEnumMacroImpl(virtual, , name, type)
#define itkFinalGetEnumMacro(name, type) ITK_DETAIL_GetEnumMacroImpl(, final, name, type)
#define itkNonVirtualGetEnumMacro(name, type) ITK_DETAIL_GetEnumMacroImpl(, , name, type)
#define itkGetEnumMacro(name, type) ITK_DETAIL_GetEnumMacroImpl(virtual, , name, type)
 
// Set a std::string member from char*/std::string. Creates Set"name"(). Implementation detail; use the public wrappers
// below.
#define ITK_DETAIL_SetStringMacroImpl(virtualKeyword, finalKeyword, name)                                 \
  virtualKeyword void Set##name(const char * _arg) finalKeyword                                           \
  {                                                                                                       \
    if (_arg && (_arg == this->m_##name))                                                                 \
    {                                                                                                     \
      return;                                                                                             \
    }                                                                                                     \
    if (_arg)                                                                                             \
    {                                                                                                     \
      this->m_##name = _arg;                                                                              \
    }                                                                                                     \
    else                                                                                                  \
    {                                                                                                     \
      this->m_##name = "";                                                                                \
    }                                                                                                     \
    this->Modified();                                                                                     \
  }                                                                                                       \
  virtualKeyword void Set##name(const std::string & _arg) finalKeyword { this->Set##name(_arg.c_str()); } \
  ITK_MACROEND_NOOP_STATEMENT

#define itkVirtualSetStringMacro(name) ITK_DETAIL_SetStringMacroImpl(virtual, , name)
#define itkFinalSetStringMacro(name) ITK_DETAIL_SetStringMacroImpl(, final, name)
#define itkNonVirtualSetStringMacro(name) ITK_DETAIL_SetStringMacroImpl(, , name)
#define itkSetStringMacro(name) ITK_DETAIL_SetStringMacroImpl(virtual, , name)
 
// Get a std::string member as const char*. Creates Get"name"(). Implementation detail; use the public wrappers below.
#define ITK_DETAIL_GetStringMacroImpl(virtualKeyword, finalKeyword, name)                       \
  virtualKeyword const char * Get##name() const finalKeyword { return this->m_##name.c_str(); } \
  ITK_MACROEND_NOOP_STATEMENT

#define itkVirtualGetStringMacro(name) ITK_DETAIL_GetStringMacroImpl(virtual, , name)
#define itkFinalGetStringMacro(name) ITK_DETAIL_GetStringMacroImpl(, final, name)
#define itkNonVirtualGetStringMacro(name) ITK_DETAIL_GetStringMacroImpl(, , name)
#define itkGetStringMacro(name) ITK_DETAIL_GetStringMacroImpl(virtual, , name)
 
// clang-format off
// Set a value constrained between min/max limits. Creates Set"name"(). Implementation detail; use the public wrappers below.
#define ITK_DETAIL_SetClampMacroImpl(virtualKeyword, finalKeyword, name, type, min, max)       \
  virtualKeyword void Set##name(type _arg) finalKeyword                                \
  {                                                                             \
    const type temp_extrema = (_arg <= min ? min : (_arg >= max ? max : _arg)); \
    itkDebugMacro("setting " << #name " to " << _arg);                          \
    ITK_GCC_PRAGMA_PUSH                                                         \
    ITK_GCC_SUPPRESS_Wfloat_equal                                               \
    if (this->m_##name != temp_extrema)                                         \
    {                                                                           \
      this->m_##name = temp_extrema;                                            \
      this->Modified();                                                         \
    }                                                                           \
    ITK_GCC_PRAGMA_POP                                                          \
  }                                                                             \
  ITK_MACROEND_NOOP_STATEMENT
// clang-format on

#define itkVirtualSetClampMacro(name, type, min, max) ITK_DETAIL_SetClampMacroImpl(virtual, , name, type, min, max)
#define itkFinalSetClampMacro(name, type, min, max) ITK_DETAIL_SetClampMacroImpl(, final, name, type, min, max)
#define itkNonVirtualSetClampMacro(name, type, min, max) ITK_DETAIL_SetClampMacroImpl(, , name, type, min, max)
#define itkSetClampMacro(name, type, min, max) ITK_DETAIL_SetClampMacroImpl(virtual, , name, type, min, max)
 
// Set object pointer (Object reference-counted). Creates Set"name"(). Implementation detail; use the public wrappers
// below.
#define ITK_DETAIL_SetObjectMacroImpl(virtualKeyword, finalKeyword, name, type) \
  virtualKeyword void Set##name(type * _arg) finalKeyword                       \
  {                                                                             \
    itkDebugMacro("setting " << #name " to " << _arg);                          \
    if (this->m_##name != _arg)                                                 \
    {                                                                           \
      this->m_##name = _arg;                                                    \
      this->Modified();                                                         \
    }                                                                           \
  }                                                                             \
  ITK_MACROEND_NOOP_STATEMENT

#define itkVirtualSetObjectMacro(name, type) ITK_DETAIL_SetObjectMacroImpl(virtual, , name, type)
#define itkFinalSetObjectMacro(name, type) ITK_DETAIL_SetObjectMacroImpl(, final, name, type)
#define itkNonVirtualSetObjectMacro(name, type) ITK_DETAIL_SetObjectMacroImpl(, , name, type)
#define itkSetObjectMacro(name, type) ITK_DETAIL_SetObjectMacroImpl(virtual, , name, type)
// NOTE: A class can use either itkGetModifiableObjectMacro
//       or itkGetObjectMacro, but not both.
//       A class can use either itkGetModifiableObjectMacro
//       or itkGetConstObjectMacro, but not both.
//       If the desired behavior is to only provide const
//       access to the itkObject ivar, then use itkGetConstObjectMacro,
//       else use itkGetModifiableObjectMacro for read/write access to
//       the ivar.
//       It is permissible to use both itkGetObjectMacro and itkGetConstObjectMacro
//       for backwards compatibility.
//       If the ITK_LEGACY_REMOVE=FALSE, then it is
//       permissible to use itkGetObjectMacro which
//       defines both signatures itk::GetXXX() and
//       itk::GetModifiableXXX()
 
// Get a raw const pointer to an object. Creates Get"name"(). Implementation detail; use the public wrappers below.
#define ITK_DETAIL_GetConstObjectMacroImpl(virtualKeyword, finalKeyword, name, type)                 \
  virtualKeyword const type * Get##name() const finalKeyword { return this->m_##name.GetPointer(); } \
  ITK_MACROEND_NOOP_STATEMENT

#define itkVirtualGetConstObjectMacro(name, type) ITK_DETAIL_GetConstObjectMacroImpl(virtual, , name, type)
#define itkFinalGetConstObjectMacro(name, type) ITK_DETAIL_GetConstObjectMacroImpl(, final, name, type)
#define itkNonVirtualGetConstObjectMacro(name, type) ITK_DETAIL_GetConstObjectMacroImpl(, , name, type)
#define itkGetConstObjectMacro(name, type) ITK_DETAIL_GetConstObjectMacroImpl(virtual, , name, type)
 
// ITK_DETAIL_GetObjectMacroImpl / ITK_DETAIL_GetModifiableObjectMacroImpl are
// implementation details; use the public wrappers below.
#if defined(ITK_FUTURE_LEGACY_REMOVE)
// In the future, the itkGetObjectMacro will be deprecated with the ITK_LEGACY_REMOVE
// flag.  For now, this very advanced feature is only available
// through manual setting of a compiler define -DITK_FUTURE_LEGACY_REMOVE
// ("/DITK_FUTURE_LEGACY_REMOVE /EHsc" with Visual Studio)
// to ease the transition from the historical GetObjectMacro to the GetModifiableObjectMacro
// Do not invoke ITK_DETAIL_GetObjectMacroImpl directly from user code; use the public wrappers below.
#  define ITK_DETAIL_GetObjectMacroImpl(virtualKeyword, finalKeyword, name, type)                 \
    virtualKeyword type * Get##name() finalKeyword                                                \
    {                                                                                             \
      purposeful_error("itkGetObjectMacro should be replaced with itkGetModifiableObjectMacro."); \
    }                                                                                             \
    ITK_MACROEND_NOOP_STATEMENT
 
// Do not invoke ITK_DETAIL_GetModifiableObjectMacroImpl directly from user code; use the public wrappers below.
#  define ITK_DETAIL_GetModifiableObjectMacroImpl(virtualKeyword, finalKeyword, name, type)          \
    virtualKeyword type * GetModifiable##name() finalKeyword { return this->m_##name.GetPointer(); } \
    ITK_DETAIL_GetConstObjectMacroImpl(virtualKeyword, finalKeyword, name, type)
 
#else // defined ( ITK_FUTURE_LEGACY_REMOVE )
// Get a raw pointer to an object. Creates Get"name"(). Implementation detail; use the public wrappers below.
#  define ITK_DETAIL_GetObjectMacroImpl(virtualKeyword, finalKeyword, name, type)          \
    virtualKeyword type * Get##name() finalKeyword { return this->m_##name.GetPointer(); } \
    ITK_MACROEND_NOOP_STATEMENT
 
// Do not invoke ITK_DETAIL_GetModifiableObjectMacroImpl directly from user code; use the public wrappers below.
#  define ITK_DETAIL_GetModifiableObjectMacroImpl(virtualKeyword, finalKeyword, name, type)          \
    virtualKeyword type * GetModifiable##name() finalKeyword { return this->m_##name.GetPointer(); } \
    ITK_DETAIL_GetConstObjectMacroImpl(virtualKeyword, finalKeyword, name, type);                    \
    ITK_DETAIL_GetObjectMacroImpl(virtualKeyword, finalKeyword, name, type)
#endif // defined ( ITK_FUTURE_LEGACY_REMOVE )

#define itkVirtualGetObjectMacro(name, type) ITK_DETAIL_GetObjectMacroImpl(virtual, , name, type)
#define itkFinalGetObjectMacro(name, type) ITK_DETAIL_GetObjectMacroImpl(, final, name, type)
#define itkNonVirtualGetObjectMacro(name, type) ITK_DETAIL_GetObjectMacroImpl(, , name, type)
#define itkGetObjectMacro(name, type) ITK_DETAIL_GetObjectMacroImpl(virtual, , name, type)
 
#define itkVirtualGetModifiableObjectMacro(name, type) ITK_DETAIL_GetModifiableObjectMacroImpl(virtual, , name, type)
#define itkFinalGetModifiableObjectMacro(name, type) ITK_DETAIL_GetModifiableObjectMacroImpl(, final, name, type)
#define itkNonVirtualGetModifiableObjectMacro(name, type) ITK_DETAIL_GetModifiableObjectMacroImpl(, , name, type)
#define itkGetModifiableObjectMacro(name, type) ITK_DETAIL_GetModifiableObjectMacroImpl(virtual, , name, type)
 
// For backwards compatibility define ITK_EXPORT to nothing
#define ITK_EXPORT
 
 
// Get a const reference to a smart pointer to an object. Creates Get"name"(). Implementation detail; use the public
// wrappers below.
#define ITK_DETAIL_GetConstReferenceObjectMacroImpl(virtualKeyword, finalKeyword, name, type)             \
  virtualKeyword const typename type::Pointer & Get##name() const finalKeyword { return this->m_##name; } \
  ITK_MACROEND_NOOP_STATEMENT

#define itkVirtualGetConstReferenceObjectMacro(name, type) \
  ITK_DETAIL_GetConstReferenceObjectMacroImpl(virtual, , name, type)
#define itkFinalGetConstReferenceObjectMacro(name, type) \
  ITK_DETAIL_GetConstReferenceObjectMacroImpl(, final, name, type)
#define itkNonVirtualGetConstReferenceObjectMacro(name, type) \
  ITK_DETAIL_GetConstReferenceObjectMacroImpl(, , name, type)
#define itkGetConstReferenceObjectMacro(name, type) ITK_DETAIL_GetConstReferenceObjectMacroImpl(virtual, , name, type)
 
// Set a const object pointer (Object reference-counted). Creates Set"name"(). Implementation detail; use the public
// wrappers below.
#define ITK_DETAIL_SetConstObjectMacroImpl(virtualKeyword, finalKeyword, name, type) \
  virtualKeyword void Set##name(const type * _arg) finalKeyword                      \
  {                                                                                  \
    itkDebugMacro("setting " << #name " to " << _arg);                               \
    if (this->m_##name != _arg)                                                      \
    {                                                                                \
      this->m_##name = _arg;                                                         \
      this->Modified();                                                              \
    }                                                                                \
  }                                                                                  \
  ITK_MACROEND_NOOP_STATEMENT

#define itkVirtualSetConstObjectMacro(name, type) ITK_DETAIL_SetConstObjectMacroImpl(virtual, , name, type)
#define itkFinalSetConstObjectMacro(name, type) ITK_DETAIL_SetConstObjectMacroImpl(, final, name, type)
#define itkNonVirtualSetConstObjectMacro(name, type) ITK_DETAIL_SetConstObjectMacroImpl(, , name, type)
#define itkSetConstObjectMacro(name, type) ITK_DETAIL_SetConstObjectMacroImpl(virtual, , name, type)
// Create "name"On()/"name"Off(). Requires a Set method. Implementation detail; use the public wrappers below.
#define ITK_DETAIL_BooleanMacroImpl(virtualKeyword, finalKeyword, name)    \
  virtualKeyword void name##On() finalKeyword { this->Set##name(true); }   \
  virtualKeyword void name##Off() finalKeyword { this->Set##name(false); } \
  ITK_MACROEND_NOOP_STATEMENT

#define itkVirtualBooleanMacro(name) ITK_DETAIL_BooleanMacroImpl(virtual, , name)
#define itkFinalBooleanMacro(name) ITK_DETAIL_BooleanMacroImpl(, final, name)
#define itkNonVirtualBooleanMacro(name) ITK_DETAIL_BooleanMacroImpl(, , name)
#define itkBooleanMacro(name) ITK_DETAIL_BooleanMacroImpl(virtual, , name)

template <typename MemberContainerType, typename CopyFromValueType, typename LoopEndType>
bool
ContainerFillWithCheck(MemberContainerType & m, const CopyFromValueType & c, const LoopEndType N)
{
  bool value_updated = false;
  for (unsigned int i = 0; i < N; ++i)
  {
    ITK_GCC_PRAGMA_PUSH
    ITK_GCC_SUPPRESS_Wfloat_equal
    if (m[i] != c)
    {
      m[i] = c;
      value_updated = true;
    }
    ITK_GCC_PRAGMA_POP
  }
  return value_updated;
}

template <typename MemberContainerType, typename CopyFromContainerType, typename LoopEndType>
bool
ContainerCopyWithCheck(MemberContainerType & m, const CopyFromContainerType & c, const LoopEndType N)
{
  bool value_updated = false;
  for (LoopEndType i = 0; i < N; ++i)
  {
    ITK_GCC_PRAGMA_PUSH
    ITK_GCC_SUPPRESS_Wfloat_equal
    if (m[i] != c[i])
    {
      m[i] = c[i];
      value_updated = true;
    }
    ITK_GCC_PRAGMA_POP
  }
  return value_updated;
}
 
// clang-format off
// Copy `count` values into the object. Creates Set"name"(). Implementation detail; use the public wrappers below.
#define ITK_DETAIL_SetVectorMacroImpl(virtualKeyword, finalKeyword, name, type, count) \
  virtualKeyword void Set##name(type data[]) finalKeyword                      \
  {                                                                     \
    if (ContainerCopyWithCheck(this->m_##name, data, count))            \
    {                                                                   \
      this->Modified();                                                 \
    }                                                                   \
  }                                                                     \
  ITK_MACROEND_NOOP_STATEMENT
// clang-format on

#define itkVirtualSetVectorMacro(name, type, count) ITK_DETAIL_SetVectorMacroImpl(virtual, , name, type, count)
#define itkFinalSetVectorMacro(name, type, count) ITK_DETAIL_SetVectorMacroImpl(, final, name, type, count)
#define itkNonVirtualSetVectorMacro(name, type, count) ITK_DETAIL_SetVectorMacroImpl(, , name, type, count)
#define itkSetVectorMacro(name, type, count) ITK_DETAIL_SetVectorMacroImpl(virtual, , name, type, count)
 
// Return pointer to type (array of type), for efficiency. Creates Get"name"(). Implementation detail; use the public
// wrappers below.
#define ITK_DETAIL_GetVectorMacroImpl(virtualKeyword, finalKeyword, name, type, count) \
  virtualKeyword type * Get##name() const finalKeyword { return this->m_##name; }      \
  ITK_MACROEND_NOOP_STATEMENT

#define itkVirtualGetVectorMacro(name, type, count) ITK_DETAIL_GetVectorMacroImpl(virtual, , name, type, count)
#define itkFinalGetVectorMacro(name, type, count) ITK_DETAIL_GetVectorMacroImpl(, final, name, type, count)
#define itkNonVirtualGetVectorMacro(name, type, count) ITK_DETAIL_GetVectorMacroImpl(, , name, type, count)
#define itkGetVectorMacro(name, type, count) ITK_DETAIL_GetVectorMacroImpl(virtual, , name, type, count)

#define itkGPUKernelClassMacro(kernel) class itkGPUKernelMacro(kernel)

#define itkGPUKernelMacro(kernel)          \
  kernel                                   \
  {                                        \
  public:                                  \
    ITK_DISALLOW_COPY_AND_MOVE(kernel);    \
    kernel() = delete;                     \
    ~kernel() = delete;                    \
    static const char * GetOpenCLSource(); \
  }
#define itkGetOpenCLSourceFromKernelMacro(kernel)                             \
  static const char * GetOpenCLSource() { return kernel::GetOpenCLSource(); } \
  ITK_MACROEND_NOOP_STATEMENT
 
// A useful macro in the PrintSelf method for printing member variables
// which are pointers to object based on the LightObject class.
#define itkPrintSelfObjectMacro(name)                              \
  if (static_cast<const LightObject *>(this->m_##name) == nullptr) \
  {                                                                \
    os << indent << #name << ": (null)" << std::endl;              \
  }                                                                \
  else                                                             \
  {                                                                \
    os << indent << #name << ": " << std::endl;                    \
    this->m_##name->Print(os, indent.GetNextIndent());             \
  }                                                                \
  ITK_MACROEND_NOOP_STATEMENT
 
 
// A useful macro in the PrintSelf method for printing boolean member
// variables.
#define itkPrintSelfBooleanMacro(name)                                           \
  os << indent << #name << ": " << (this->m_##name ? "On" : "Off") << std::endl; \
  ITK_MACROEND_NOOP_STATEMENT
 
 
// Set a decorated output. Defines Set"name"Output() and Set"name"(value). Implementation detail; use the public
// wrappers below.
#define ITK_DETAIL_SetDecoratedOutputMacroImpl(virtualKeyword, finalKeyword, name, type)                             \
  virtualKeyword void Set##name##Output(const SimpleDataObjectDecorator<type> * _arg) finalKeyword                   \
  {                                                                                                                  \
    itkDebugMacro("setting output " #name " to " << _arg);                                                           \
    if (_arg != itkDynamicCastInDebugMode<SimpleDataObjectDecorator<type> *>(this->ProcessObject::GetOutput(#name))) \
    {                                                                                                                \
      this->ProcessObject::SetOutput(#name, const_cast<SimpleDataObjectDecorator<type> *>(_arg));                    \
      this->Modified();                                                                                              \
    }                                                                                                                \
  }                                                                                                                  \
  virtualKeyword void Set##name(const type & _arg) finalKeyword                                                      \
  {                                                                                                                  \
    using DecoratorType = SimpleDataObjectDecorator<type>;                                                           \
    itkDebugMacro("setting output " #name " to " << _arg);                                                           \
    DecoratorType * output = itkDynamicCastInDebugMode<DecoratorType *>(this->ProcessObject::GetOutput(#name));      \
    if (output)                                                                                                      \
    {                                                                                                                \
      if (output->Get() == _arg)                                                                                     \
      {                                                                                                              \
        return;                                                                                                      \
      }                                                                                                              \
      else                                                                                                           \
      {                                                                                                              \
        output->Set(_arg);                                                                                           \
      }                                                                                                              \
    }                                                                                                                \
    else                                                                                                             \
    {                                                                                                                \
      auto newOutput = DecoratorType::New();                                                                         \
      newOutput->Set(_arg);                                                                                          \
      this->Set##name##Output(newOutput);                                                                            \
    }                                                                                                                \
  }                                                                                                                  \
  ITK_MACROEND_NOOP_STATEMENT

#define itkVirtualSetDecoratedOutputMacro(name, type) ITK_DETAIL_SetDecoratedOutputMacroImpl(virtual, , name, type)
#define itkFinalSetDecoratedOutputMacro(name, type) ITK_DETAIL_SetDecoratedOutputMacroImpl(, final, name, type)
#define itkNonVirtualSetDecoratedOutputMacro(name, type) ITK_DETAIL_SetDecoratedOutputMacroImpl(, , name, type)
#define itkSetDecoratedOutputMacro(name, type) ITK_DETAIL_SetDecoratedOutputMacroImpl(virtual, , name, type)
 
// Get a decorated output. Defines Get"name"Output() and Get"name"(). Implementation detail; use the public wrappers
// below.
#define ITK_DETAIL_GetDecoratedOutputMacroImpl(virtualKeyword, finalKeyword, name, type)                              \
  virtualKeyword const SimpleDataObjectDecorator<type> * Get##name##Output() const finalKeyword                       \
  {                                                                                                                   \
    itkDebugMacro("returning output " << #name " of " << this->ProcessObject::GetOutput(#name));                      \
    return itkDynamicCastInDebugMode<const SimpleDataObjectDecorator<type> *>(this->ProcessObject::GetOutput(#name)); \
  }                                                                                                                   \
  virtualKeyword const type & Get##name() const finalKeyword                                                          \
  {                                                                                                                   \
    itkDebugMacro("Getting output " #name);                                                                           \
    using DecoratorType = SimpleDataObjectDecorator<type>;                                                            \
    const DecoratorType * output =                                                                                    \
      itkDynamicCastInDebugMode<const DecoratorType *>(this->ProcessObject::GetOutput(#name));                        \
    if (output == nullptr)                                                                                            \
    {                                                                                                                 \
      itkExceptionStringMacro("output" #name " is not set");                                                          \
    }                                                                                                                 \
    return output->Get();                                                                                             \
  }                                                                                                                   \
  ITK_MACROEND_NOOP_STATEMENT

#define itkVirtualGetDecoratedOutputMacro(name, type) ITK_DETAIL_GetDecoratedOutputMacroImpl(virtual, , name, type)
#define itkFinalGetDecoratedOutputMacro(name, type) ITK_DETAIL_GetDecoratedOutputMacroImpl(, final, name, type)
#define itkNonVirtualGetDecoratedOutputMacro(name, type) ITK_DETAIL_GetDecoratedOutputMacroImpl(, , name, type)
#define itkGetDecoratedOutputMacro(name, type) ITK_DETAIL_GetDecoratedOutputMacroImpl(virtual, , name, type)
// ITK_FUTURE_DEPRECATED is only for internal use, within the implementation of ITK. It allows triggering "deprecated"
// warnings when legacy support is removed, which warn that a specific feature may be removed in the future.
#if defined(ITK_LEGACY_REMOVE) && !defined(ITK_LEGACY_SILENT)
#  define ITK_FUTURE_DEPRECATED(message) [[deprecated(message)]]
#else
#  define ITK_FUTURE_DEPRECATED(message)
#endif
 
#if __cplusplus >= 202002L
#  define ITK_NODISCARD(message) [[nodiscard(message)]]
#else
#  define ITK_NODISCARD(message) [[nodiscard]]
#endif
 
//-*-*-*
 
#if defined(ITK_LEGACY_REMOVE)
#  define itkExposeEnumValue(name) \
    static_assert(false, "ERROR: Replace static_cast<int>(name) with with proper enumeration instead of integer")
 
#  define ITK_NOEXCEPT_OR_THROW static_assert(false, "Replace ITK_NOEXCEPT_OR_THROW with ITK_NOEXCEPT")
 
#  define ITK_DELETE_FUNCTION static_assert(false, "ERROR: ITK_DELETE_FUNCTION must be replaced with `= delete`"
#  define ITK_CONSTEXPR_FUNC static_assert(false, "ERROR: ITK_CONSTEXPR_FUNC must be replaced with 'constexpr'")
#  define ITK_CONSTEXPR_VAR static_assert(false, "ERROR: ITK_CONSTEXPR_VAR must be replaced with 'constexpr'")
 
#  define ITK_FALLTHROUGH static_assert(false, "ERROR: ITK_FALLTHROUGH must be replaced with '[[fallthrough]]'")
 
// Defines which used to be in itk_compiler_detection.h
#  define ITK_ALIGNAS static_assert(false, "ERROR: ITK_ALIGNAS must be replaced with 'alignas'")
#  define ITK_ALIGNOF static_assert(false, "ERROR: ITK_ALIGNOF must be replaced with 'alignof'")
#  define ITK_DEPRECATED static_assert(false, "ERROR: ITK_DEPRECATED must be replaced with '[[deprecated]]'")
#  define ITK_DEPRECATED_MSG \
    static_assert(false, "ERROR: ITK_DEPRECATED_MSG must be replaced with '[[deprecated(MSG)]]'")
#  define ITK_CONSTEXPR static_assert(false, "ERROR: ITK_CONSTEXPR must be replaced with 'constexpr'")
#  define ITK_DELETED_FUNCTION static_assert(false, "ERROR: ITK_DELETED_FUNCTION must be replaced with '= delete'")
#  define ITK_EXTERN_TEMPLATE static_assert(false, "ERROR: ITK_EXTERN_TEMPLATE must be replaced with 'extern'")
#  define ITK_FINAL static_assert(false, "ERROR: ITK_FINAL must be replaced with 'final'")
#  define ITK_NOEXCEPT static_assert(false, "ERROR: ITK_NOEXCEPT must be replaced with 'noexcept'")
#  define ITK_NOEXCEPT_EXPR static_assert(false, "ERROR: ITK_NOEXCEPT_EXPR must be replaced with 'noexcept'")
#  define ITK_NULLPTR static_assert(false, "ERROR: ITK_NULLPTR must be replaced with 'nullptr'")
#  define ITK_OVERRIDE static_assert(false, "ERROR: ITK_OVERRIDE must be replaced with 'override'")
#  define ITK_STATIC_ASSERT static_assert(false, "ERROR: ITK_STATIC_ASSERT must be replaced with 'static_assert'")
#  define ITK_STATIC_ASSERT_MSG \
    static_assert(false, "ERROR: ITK_STATIC_ASSERT_MSG must be replaced with 'static_assert'")
#  define ITK_THREAD_LOCAL static_assert(false, "ERROR: ITK_THREAD_LOCAL must be replaced with 'thread_local'")
 
// A macro for methods which are const in ITKv5 and ITKv6 require const for functions
#  define ITKv5_CONST static_assert(false, "ERROR: ITKv5_CONST must be replaced with 'const'")
 
#  define ITK_ITERATOR_VIRTUAL static_assert(false, "ERROR: ITK_ITERATOR_VIRTUAL must be removed'")
#  define ITK_ITERATOR_OVERRIDE static_assert(false, "ERROR: ITK_ITERATOR_OVERRIDE must be removed")
#  define ITK_ITERATOR_FINAL static_assert(false, "ERROR: ITK_ITERATOR_FINAL must be removed")
 
#else
// DEPRECATED: These macros are left here for compatibility with remote modules.
// Once they have been removed from all known remote modules, this code should
// be removed.
 
// Future remove `#define itkExposeEnumValue(name)`
// "Replace type of  `name` with proper enumeration instead of integer.
#  define itkExposeEnumValue(name) static_cast<int>(name)
 
 
#  define ITK_NOEXCEPT_OR_THROW ITK_NOEXCEPT
 
#  define ITK_FALLTHROUGH [[fallthrough]]
 
#  define ITK_DELETE_FUNCTION = delete
 
#  define ITK_CONSTEXPR_FUNC constexpr
#  define ITK_CONSTEXPR_VAR constexpr
 
// Defines which used to be in itk_compiler_detection.h
#  define ITK_ALIGNAS(X) alignas(X)
#  define ITK_ALIGNOF(X) alignof(X)
#  define ITK_DEPRECATED [[deprecated]]
#  define ITK_DEPRECATED_MSG(MSG) [[deprecated(MSG)]]
#  define ITK_CONSTEXPR constexpr
#  define ITK_DELETED_FUNCTION = delete
#  define ITK_EXTERN_TEMPLATE extern
#  define ITK_FINAL final
#  define ITK_NOEXCEPT noexcept
#  define ITK_NOEXCEPT_EXPR(X) noexcept(X)
#  define ITK_NULLPTR nullptr
#  define ITK_OVERRIDE override
#  define ITK_STATIC_ASSERT(X) static_assert(X, #X)
#  define ITK_STATIC_ASSERT_MSG(X, MSG) static_assert(X, MSG)
#  define ITK_THREAD_LOCAL thread_local
 
// A macro for methods which are const in after ITKv4
#  define ITKv5_CONST const
 
#  define ITK_ITERATOR_VIRTUAL  /*purposefully empty for ITKv6, iterators are not virtual for performance reasons*/
#  define ITK_ITERATOR_OVERRIDE /*purposefully empty for ITKv6, iterators are not virtual for performance reasons*/
#  define ITK_ITERATOR_FINAL    /*purposefully empty for ITKv6, iterators are not virtual for performance reasons*/
#endif
 
#define allow_inclusion_of_itkExceptionObject_h
// Must include itkExceptionObject.h at the end of the file
// because it depends on the macros defined above
#include "itkExceptionObject.h"
 
 
#undef allow_inclusion_of_itkExceptionObject_h
 
 
#include "itkPrintHelper.h"
#endif // itkMacro_h