ITK  5.4.0
Insight Toolkit
itkMacro.h
Go to the documentation of this file.
1 /*=========================================================================
2  *
3  * Copyright NumFOCUS
4  *
5  * Licensed under the Apache License, Version 2.0 (the "License");
6  * you may not use this file except in compliance with the License.
7  * You may obtain a copy of the License at
8  *
9  * https://www.apache.org/licenses/LICENSE-2.0.txt
10  *
11  * Unless required by applicable law or agreed to in writing, software
12  * distributed under the License is distributed on an "AS IS" BASIS,
13  * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
14  * See the License for the specific language governing permissions and
15  * limitations under the License.
16  *
17  *=========================================================================*/
18 /*=========================================================================
19  *
20  * Portions of this file are subject to the VTK Toolkit Version 3 copyright.
21  *
22  * Copyright (c) Ken Martin, Will Schroeder, Bill Lorensen
23  *
24  * For complete copyright, license and disclaimer of warranty information
25  * please refer to the NOTICE file at the top of the ITK source tree.
26  *
27  *=========================================================================*/
38 #ifndef itkMacro_h
39 #define itkMacro_h
40 
41 #include "itkWin32Header.h"
42 #include "itkConfigure.h"
43 #include "ITKCommonExport.h"
44 
45 #include <typeinfo>
46 
47 #include <string>
48 #include <cstdlib>
49 #ifndef NDEBUG
50 # include <cassert>
51 # include "itkPrintHelper.h" // for ostream operator<<std::vector<T>
52 #endif
53 
54 #include <sstream>
55 #include <type_traits> // For is_same, remove_const, and remove_reference.
56 
61 namespace itk
62 {
63 // end namespace itk - this is here for documentation purposes
64 }
65 
68 #define itkNotUsed(x)
69 
70 // clang-format off
71 
81 #define ITK_NOOP_STATEMENT static_assert(true, "")
82 
83 
84 #if defined(ITK_FUTURE_LEGACY_REMOVE)
85 
86 # define ITK_MACROEND_NOOP_STATEMENT ITK_NOOP_STATEMENT
87 #else
88 /* NOTE: The ITK_MACROEND_NOOP_STATEMENT must be defined to nothing
89  * in order to maintain backwards compatibility with earlier macro
90  * uses that may or may not have ';' after the macro is used. */
91 /* Purposefully empty */
92 # define ITK_MACROEND_NOOP_STATEMENT
93 #endif
94 // clang-format on
95 
96 // Define ITK_PRAGMA macro.
97 //
98 // It sets "#pragma" preprocessor directives without expecting the arguments
99 // to be quoted.
100 #define ITK_PRAGMA(x) _Pragma(#x)
101 
102 // The GCC/Clang compilers have many useful non-default compiler warnings
103 // that tend to have a high false positive rate or are otherwise not always appropriate.
104 // The following set of defines allows us to suppress instances of said warnings.
105 
106 // For GCC and Clang (Clang also identifies itself as GCC, and supports these pragmas):
107 #if defined(__GNUC__)
108 # define ITK_GCC_PRAGMA_PUSH ITK_PRAGMA(GCC diagnostic push)
109 # define ITK_GCC_PRAGMA_POP ITK_PRAGMA(GCC diagnostic pop)
110 # define ITK_GCC_SUPPRESS_Wfloat_equal ITK_PRAGMA(GCC diagnostic ignored "-Wfloat-equal")
111 # define ITK_GCC_SUPPRESS_Wformat_nonliteral ITK_PRAGMA(GCC diagnostic ignored "-Wformat-nonliteral")
112 #else
113 # define ITK_GCC_PRAGMA_PUSH
114 # define ITK_GCC_PRAGMA_POP
115 # define ITK_GCC_SUPPRESS_Wfloat_equal
116 # define ITK_GCC_SUPPRESS_Wformat_nonliteral
117 #endif
118 
119 // For Clang only (and not GCC):
120 #if defined(__clang__) && defined(__has_warning)
121 # define ITK_CLANG_PRAGMA_PUSH ITK_PRAGMA(clang diagnostic push)
122 # define ITK_CLANG_PRAGMA_POP ITK_PRAGMA(clang diagnostic pop)
123 #else
124 # define ITK_CLANG_PRAGMA_PUSH
125 # define ITK_CLANG_PRAGMA_POP
126 #endif
127 
128 // These were not intended as public API, but some code was nevertheless using them.
129 // Support the pre ITK 5.4 spelling for compatibility.
130 #define CLANG_PRAGMA_PUSH ITK_CLANG_PRAGMA_PUSH
131 #define CLANG_PRAGMA_POP ITK_CLANG_PRAGMA_POP
132 #define CLANG_SUPPRESS_Wfloat_equal ITK_GCC_SUPPRESS_Wfloat_equal
133 
134 #if !defined(ITK_LEGACY_REMOVE)
135 // Issue warning if deprecated preprocessor flag is used.
136 # define CLANG_SUPPRESS_Wcpp14_extensions \
137  [[deprecated("Remove deprecated CLANG_SUPPRESS_Wcpp14_extensions c++14 warning suppression")]] void * \
138  CLANG_SUPPRESS_Wcpp14_extensions = nullptr;
139 #endif
140 
141 // Intel compiler convenience macros
142 #if defined(__INTEL_COMPILER)
143 # define INTEL_PRAGMA_WARN_PUSH ITK_PRAGMA(warning push)
144 # define INTEL_PRAGMA_WARN_POP ITK_PRAGMA(warning pop)
145 # define INTEL_SUPPRESS_warning_1292 ITK_PRAGMA(warning disable 1292)
146 #else
147 # define INTEL_PRAGMA_WARN_PUSH
148 # define INTEL_PRAGMA_WARN_POP
149 # define INTEL_SUPPRESS_warning_1292
150 #endif
151 
152 // Define ITK_GCC_PRAGMA_DIAG(param1 [param2 [...]]) macro.
153 //
154 // This macro sets a pragma diagnostic
155 //
156 // Define ITK_GCC_PRAGMA_DIAG_(PUSH|POP) macros.
157 //
158 // These macros respectively push and pop the diagnostic context
159 //
160 #if defined(__GNUC__) && !defined(__INTEL_COMPILER)
161 # define ITK_GCC_PRAGMA_DIAG(x) ITK_PRAGMA(GCC diagnostic x)
162 # define ITK_GCC_PRAGMA_DIAG_PUSH() ITK_GCC_PRAGMA_DIAG(push)
163 # define ITK_GCC_PRAGMA_DIAG_POP() ITK_GCC_PRAGMA_DIAG(pop)
164 #else
165 # define ITK_GCC_PRAGMA_DIAG(x)
166 # define ITK_GCC_PRAGMA_DIAG_PUSH()
167 # define ITK_GCC_PRAGMA_DIAG_POP()
168 #endif
169 
170 /*
171  * ITK only supports MSVC++ 14.2 and greater
172  * MSVC++ 14.2 _MSC_VER == 1920 (Visual Studio 2019 Version 16.0)
173  */
174 #if defined(_MSC_VER) && (_MSC_VER < 1920)
175 # error "MSVC versions before Visual Studio 2019 are not supported under ITKv5.4"
176 #endif
177 #if defined(__SUNPRO_CC) && (__SUNPRO_CC < 0x5140)
178 # error "SUNPro C++ < 5.14.0 is not supported under ITKv5 and above"
179 #endif
180 #if defined(__CYGWIN__)
181 # error "The Cygwin compiler is not supported in ITKv4 and above"
182 #endif
183 #if defined(__BORLANDC__)
184 # error "The Borland C compiler is not supported in ITKv4 and above"
185 #endif
186 #if defined(__MWERKS__)
187 # error "The MetroWerks compiler is not supported in ITKv4 and above"
188 #endif
189 #if defined(__GNUC__) && !defined(__clang__) && !defined(__INTEL_COMPILER) && (__GNUC__ < 7)
190 # error "GCC < 7 is not supported under ITKv5.4"
191 #endif
192 #if defined(__sgi)
193 // This is true for IRIX 6.5.18m with MIPSPro 7.3.1.3m.
194 // TODO: At some future point, it may be necessary to
195 // define a minimum __sgi version that will work.
196 # error "The SGI compiler is not supported under ITKv4 and above"
197 #endif
198 #if defined(__APPLE__)
199 # if defined(__clang__) && (__cplusplus < 201703L)
200 # error "Apple LLVM compiling with a standard less than C++17 is not supported under ITKv5.4"
201 # endif
202 #elif defined(__clang__) && (__clang_major__ < 5)
203 # error "Clang < 5 is not supported under ITKv5.4"
204 #endif
205 #if defined(__INTEL_COMPILER) && (__INTEL_COMPILER < 1910)
206 # error "Intel C++ < 19.1 is not supported under ITKv5.4"
207 #endif
208 
209 // Setup symbol exports
210 #if defined(_WIN32) || defined(WIN32)
211 # define ITK_ABI_IMPORT __declspec(dllimport)
212 # define ITK_ABI_EXPORT __declspec(dllexport)
213 # define ITK_ABI_HIDDEN
214 #else
215 # ifdef __GNUC__
216 # define ITK_ABI_IMPORT __attribute__((visibility("default")))
217 # define ITK_ABI_EXPORT __attribute__((visibility("default")))
218 # define ITK_ABI_HIDDEN __attribute__((visibility("hidden")))
219 # else
220 # define ITK_ABI_IMPORT
221 # define ITK_ABI_EXPORT
222 # define ITK_ABI_HIDDEN
223 # endif
224 #endif
225 
226 // Setup symbol exports
227 #ifndef ITK_TEMPLATE_EXPORT
228 # ifdef ITK_TEMPLATE_VISIBILITY_DEFAULT
229 # define ITK_TEMPLATE_EXPORT __attribute__((visibility("default")))
230 # else
231 # define ITK_TEMPLATE_EXPORT
232 # endif
233 #endif
234 
235 // Setup symbol exports
236 #ifdef ITK_TEMPLATE_VISIBILITY_DEFAULT
237 # define ITK_FORCE_EXPORT_MACRO(moduleName) __attribute__((visibility("default")))
238 #else
239 # define ITK_FORCE_EXPORT_MACRO(moduleName) moduleName##_EXPORT
240 #endif
241 
242 #ifndef ITK_FORWARD_EXPORT
243 // If build with shared libraries, on MacOS, if USE_COMPILER_HIDDEN_VISIBILITY is ON
244 # if defined(__APPLE__) && defined(ITK_TEMPLATE_VISIBILITY_DEFAULT) && defined(ITK_BUILD_SHARED_LIBS) && \
245  defined(USE_COMPILER_HIDDEN_VISIBILITY)
246 # define ITK_FORWARD_EXPORT __attribute__((visibility("default")))
247 # else
248 # define ITK_FORWARD_EXPORT
249 # endif
250 #endif
251 
252 
253 //-*-*-*
254 // The following deprecations should be removed in ITKV6 and later
255 // NOTE DEPRECATED should be ITK_NOEXCEPT
256 #define ITK_NOEXCEPT_OR_THROW error "Replace ITK_NOEXCEPT_OR_THROW with ITK_NOEXCEPT"
257 // NOTE DEPRECATED! should be ITK_COMPILER_CXX_STATIC_ASSERT
258 #if !defined(ITK_LEGACY_REMOVE)
259 # define ITK_DELETE_FUNCTION = delete
260 #else
261 # define ITK_DELETE_FUNCTION error "Replace ITK_DELETE_FUNCTION with = delete"
262 #endif
263 //-*-*-*
264 
265 // DEPRECATED: These macros are left here for compatibility with remote modules.
266 // Once they have been removed from all known remote modules, this code should
267 // be removed.
268 #if defined(ITK_FUTURE_LEGACY_REMOVE)
269 # define ITK_CONSTEXPR_FUNC "Replace ITK_CONSTEXPR_FUNC with constexpr"
270 # define ITK_CONSTEXPR_VAR "Replace ITK_CONSTEXPR_VAR with constexpr"
271 
272 # define itkExposeEnumValue(name) static_cast<int>(name)
273 // Future remove# define itkExposeEnumValue(name) "Replace type of " # name " with proper enumeration instead of
274 // integer."
275 #else
276 # define ITK_CONSTEXPR_FUNC constexpr
277 # define ITK_CONSTEXPR_VAR constexpr
278 
280 # define itkExposeEnumValue(name) static_cast<int>(name)
281 #endif
282 
283 #if !defined(ITK_FUTURE_LEGACY_REMOVE)
284 # define ITK_FALLTHROUGH [[fallthrough]]
285 #else
286 # define ITK_FALLTHROUGH static_assert(false, "ERROR: ITK_FALLTHROUGH must be replaced with [[fallthrough]]")
287 #endif
288 
309 #define itkNewMacro(x) \
310  itkSimpleNewMacro(x); \
311  itkCreateAnotherMacro(x); \
312  itkCloneMacro(x); \
313  ITK_MACROEND_NOOP_STATEMENT
314 
316 #define itkSimpleNewMacro(x) \
317  static Pointer New() \
318  { \
319  Pointer smartPtr = ::itk::ObjectFactory<x>::Create(); \
320  if (smartPtr == nullptr) \
321  { \
322  smartPtr = new x(); \
323  } \
324  smartPtr->UnRegister(); \
325  return smartPtr; \
326  } \
327  ITK_MACROEND_NOOP_STATEMENT
328 
329 #define itkCreateAnotherMacro(x) \
330  ::itk::LightObject::Pointer CreateAnother() const override { return x::New().GetPointer(); } \
331  ITK_MACROEND_NOOP_STATEMENT
332 
333 #define itkCloneMacro(x) \
334  Pointer Clone() const \
335  { \
336  Pointer rval = dynamic_cast<x *>(this->InternalClone().GetPointer()); \
337  return rval; \
338  } \
339  ITK_MACROEND_NOOP_STATEMENT
340 
344 #define itkFactoryOnlyNewMacro(x) \
345  itkSimpleFactoryOnlyNewMacro(x); \
346  itkCreateAnotherMacro(x); \
347  itkCloneMacro(x); \
348  ITK_MACROEND_NOOP_STATEMENT
349 
351 #define itkSimpleFactoryOnlyNewMacro(x) \
352  static auto New()->Pointer \
353  { \
354  Pointer smartPtr = ::itk::ObjectFactory<x>::Create(); \
355  if (smartPtr == nullptr) \
356  { \
357  itkSpecializedMessageExceptionMacro(ExceptionObject, \
358  "Object factory failed to instantiate " << typeid(x).name()); \
359  } \
360  smartPtr->UnRegister(); \
361  return smartPtr; \
362  } \
363  ITK_MACROEND_NOOP_STATEMENT
364 
377 #define itkFactorylessNewMacro(x) \
378  static Pointer New() \
379  { \
380  x * rawPtr = new x(); \
381  Pointer smartPtr = rawPtr; \
382  rawPtr->UnRegister(); \
383  return smartPtr; \
384  } \
385  itkCreateAnotherMacro(x); \
386  ITK_MACROEND_NOOP_STATEMENT
387 
389 //
390 // A macro to disallow the copy constructor, copy assignment,
391 // move constructor, and move assignment functions.
392 // This should be used in the public: declarations for a class
393 //
394 // ITK's paradigm for smart pointer and pipeline consistency
395 // prohibits the use of copy/move construction and copy/move assignment
396 // functions.
397 //
398 #define ITK_DISALLOW_COPY_AND_MOVE(TypeName) \
399  TypeName(const TypeName &) = delete; \
400  TypeName & operator=(const TypeName &) = delete; \
401  TypeName(TypeName &&) = delete; \
402  TypeName & operator=(TypeName &&) = delete
403 
404 #if !defined(ITK_FUTURE_LEGACY_REMOVE)
405 # define ITK_DISALLOW_COPY_AND_ASSIGN(TypeName) ITK_DISALLOW_COPY_AND_MOVE(TypeName)
406 #else
407 # define ITK_DISALLOW_COPY_AND_ASSIGN(TypeName) \
408  static_assert(false, "Replace deprecated ITK_DISALLOW_COPY_AND_ASSIGN with modern ITK_DISALLOW_COPY_AND_MOVE")
409 #endif
410 
411 
419 #define ITK_DEFAULT_COPY_AND_MOVE(TypeName) \
420  TypeName(const TypeName &) = default; \
421  TypeName & operator=(const TypeName &) = default; \
422  TypeName(TypeName &&) = default; \
423  TypeName & operator=(TypeName &&) = default
424 
427 // When ITK_EXPERIMENTAL_CXX20_REWRITTEN_UNEQUAL_OPERATOR is defined, ITK uses
428 // the ability for operator!= to be rewritten automatically in terms of
429 // operator==, as introduced with C++20. This macro is experimental. It may be
430 // modified, renamed, or removed without backward compatibility support.
431 #if __cplusplus >= 202002L
432 # define ITK_EXPERIMENTAL_CXX20_REWRITTEN_UNEQUAL_OPERATOR
433 #endif
434 
435 // Note: The following macro, ITK_UNEQUAL_OPERATOR_MEMBER_FUNCTION(TypeName),
436 // is only for internal use within the implementation of ITK. It may be
437 // modified, renamed, or removed without backward compatibility support.
438 #ifdef ITK_EXPERIMENTAL_CXX20_REWRITTEN_UNEQUAL_OPERATOR
439 // With C++20, operator!= is automatically rewritten in terms of the
440 // corresponding operator==.
441 # define ITK_UNEQUAL_OPERATOR_MEMBER_FUNCTION(TypeName) ITK_MACROEND_NOOP_STATEMENT
442 #else
443 // For C++14 and C++17, this macro defines an operator!= member function that
444 // just calls the corresponding operator== member function.
445 # define ITK_UNEQUAL_OPERATOR_MEMBER_FUNCTION(TypeName) \
446  bool operator!=(const TypeName & other) const { return !(this->operator==(other)); } \
447  ITK_MACROEND_NOOP_STATEMENT
448 #endif
449 
450 
451 // Internal macro (not part of the public ITK API), used to implement `GetNameOfClass()` member functions.
452 #define itkInternalGetNameOfClassImplementationMacro(thisClass) \
453  { \
454  static_assert(std::is_same_v<thisClass, std::remove_const_t<std::remove_reference_t<decltype(*this)>>>, \
455  "The macro argument `" #thisClass \
456  "` appears incorrect! It should correspond with the name of this class!"); \
457  return #thisClass; \
458  } \
459  ITK_MACROEND_NOOP_STATEMENT
460 
461 
465 #define itkVirtualGetNameOfClassMacro(thisClass) \
466  virtual const char * GetNameOfClass() const itkInternalGetNameOfClassImplementationMacro(thisClass)
467 
468 #define itkOverrideGetNameOfClassMacro(thisClass) \
469  const char * GetNameOfClass() const override itkInternalGetNameOfClassImplementationMacro(thisClass)
470 
471 #ifdef ITK_FUTURE_LEGACY_REMOVE
472 # define itkTypeMacro(thisClass, superclass) \
473  static_assert(false, \
474  "In a future revision of ITK, the macro `itkTypeMacro(thisClass, superclass)` will be removed. " \
475  "Please call `itkOverrideGetNameOfClassMacro(thisClass)` instead!")
476 # define itkTypeMacroNoParent(thisClass) \
477  static_assert(false, \
478  "In a future revision of ITK, the macro `itkTypeMacroNoParent(thisClass)` will be removed. " \
479  "Please call `itkVirtualGetNameOfClassMacro(thisClass)` instead!")
480 #else
481 
485 # define itkTypeMacro(thisClass, superclass) itkOverrideGetNameOfClassMacro(thisClass)
486 # define itkTypeMacroNoParent(thisClass) itkVirtualGetNameOfClassMacro(thisClass)
487 #endif
488 
489 
490 namespace itk
491 {
498 extern ITKCommon_EXPORT void
499 OutputWindowDisplayText(const char *);
502 extern ITKCommon_EXPORT void
503 OutputWindowDisplayErrorText(const char *);
504 
505 extern ITKCommon_EXPORT void
506 OutputWindowDisplayWarningText(const char *);
507 
508 extern ITKCommon_EXPORT void
509 OutputWindowDisplayGenericOutputText(const char *);
510 
511 extern ITKCommon_EXPORT void
512 OutputWindowDisplayDebugText(const char *);
513 
514 } // end namespace itk
515 
516 // The itkDebugStatement is to be used to protect code that is only used in the itkDebugMacro
521 #if defined(NDEBUG)
522 # define itkDebugMacro(x) ITK_NOOP_STATEMENT
523 # define itkDebugStatement(x) ITK_NOOP_STATEMENT
524 #else
525 # define itkDebugMacro(x) \
526  do \
527  { \
528  using namespace ::itk::print_helper; /* for ostream << std::vector<T> */ \
529  if (this->GetDebug() && ::itk::Object::GetGlobalWarningDisplay()) \
530  { \
531  std::ostringstream itkmsg; \
532  itkmsg << "Debug: In " __FILE__ ", line " << __LINE__ << '\n' \
533  << this->GetNameOfClass() << " (" << this << "): " x << "\n\n"; \
534  ::itk::OutputWindowDisplayDebugText(itkmsg.str().c_str()); \
535  } \
536  } while (0)
537 
539 // The itkDebugStatement is to be used to protect code that is only
540 // used in the itkDebugMacro
541 # define itkDebugStatement(x) x
542 #endif
543 
547 #define itkWarningMacro(x) \
548  do \
549  { \
550  if (::itk::Object::GetGlobalWarningDisplay()) \
551  { \
552  std::ostringstream itkmsg; \
553  itkmsg << "WARNING: In " __FILE__ ", line " << __LINE__ << '\n' \
554  << this->GetNameOfClass() << " (" << this << "): " x << "\n\n"; \
555  ::itk::OutputWindowDisplayWarningText(itkmsg.str().c_str()); \
556  } \
557  } while (0)
558 
560 #define itkWarningStatement(x) x
561 
562 #if defined(ITK_CPP_FUNCTION)
563 # if defined(_WIN32) && !defined(__MINGW32__) && !defined(ITK_WRAPPING_PARSER)
564 # define ITK_LOCATION __FUNCSIG__
565 # elif defined(__GNUC__)
566 # define ITK_LOCATION __PRETTY_FUNCTION__
567 # else
568 # define ITK_LOCATION __FUNCTION__
569 # endif
570 #else
571 # define ITK_LOCATION "unknown"
572 #endif
573 
574 #define itkDeclareExceptionMacro(newexcp, parentexcp, whatmessage) \
575  namespace itk \
576  { \
577  class newexcp : public parentexcp \
578  { \
579  public: \
580  /* default message provides backward compatibility for a given exception type */ \
581  static constexpr const char * const default_exception_message = whatmessage; \
582  /* Inherit the constructors from its base class. */ \
583  using parentexcp::parentexcp; \
584  itkOverrideGetNameOfClassMacro(newexcp); \
585  }; \
586  } \
587  ITK_MACROEND_NOOP_STATEMENT
588 
589 
590 #define itkSpecializedMessageExceptionMacro(ExceptionType, x) \
591  { \
592  std::ostringstream exceptionDescriptionOutputStringStream; \
593  exceptionDescriptionOutputStringStream << "ITK ERROR: " x; \
594  throw ::itk::ExceptionType( \
595  std::string{ __FILE__ }, __LINE__, exceptionDescriptionOutputStringStream.str(), std::string{ ITK_LOCATION }); \
596  } \
597  ITK_MACROEND_NOOP_STATEMENT
598 
599 #define itkSpecializedExceptionMacro(ExceptionType) \
600  itkSpecializedMessageExceptionMacro(ExceptionType, << ::itk::ExceptionType::default_exception_message)
601 
605 #define itkExceptionMacro(x) \
606  itkSpecializedMessageExceptionMacro(ExceptionObject, << this->GetNameOfClass() << '(' << this << "): " x)
607 
608 #define itkGenericExceptionMacro(x) itkSpecializedMessageExceptionMacro(ExceptionObject, x)
609 
610 #define itkGenericOutputMacro(x) \
611  { \
612  if (::itk::Object::GetGlobalWarningDisplay()) \
613  { \
614  std::ostringstream itkmsg; \
615  itkmsg << "WARNING: In " __FILE__ ", line " << __LINE__ << "\n" x << "\n\n"; \
616  ::itk::OutputWindowDisplayGenericOutputText(itkmsg.str().c_str()); \
617  } \
618  } \
619  ITK_MACROEND_NOOP_STATEMENT
620 
621 //----------------------------------------------------------------------------
622 // Macros for simplifying the use of logging
623 //
624 #define itkLogMacro(x, y) \
625  { \
626  if (this->GetLogger()) \
627  { \
628  this->GetLogger()->Write(::itk::LoggerBase::x, y); \
629  } \
630  } \
631  ITK_MACROEND_NOOP_STATEMENT
632 
633 #define itkLogMacroStatic(obj, x, y) \
634  { \
635  if (obj->GetLogger()) \
636  { \
637  obj->GetLogger()->Write(::itk::LoggerBase::x, y); \
638  } \
639  } \
640  ITK_MACROEND_NOOP_STATEMENT
641 
642 //----------------------------------------------------------------------------
643 // Setup legacy code policy.
644 //
645 // CMake options:
646 // - When ITK_LEGACY_REMOVE:BOOL=ON, legacy code is hidden, thus causing compiler errors for code that depends on it
647 // - When ITK_LEGACY_REMOVE:BOOL=OFF, and ITK_LEGACY_SILENT:BOOL=ON, use
648 // of legacy code will not produce compiler warnings.
649 // - When ITK_LEGACY_REMOVE:BOOL=OFF, and ITK_LEGACY_SILENT:BOOL=OFF, use
650 // of legacy code will produce compiler warnings
651 //
652 // ITK_LEGACY_SILENT silently use legacy code. The default is to warn about legacy code use.
653 //
654 // Source files that test the legacy code may define ITK_LEGACY_TEST
655 // like this:
656 //
657 // #define ITK_LEGACY_TEST
658 // #include "itkClassWithDeprecatedMethod.h"
659 //
660 // in order to silence the warnings for calling deprecated methods.
661 // No other source files in ITK should call the methods since they are
662 // provided only for compatibility with older user code.
663 
664 // Define itkLegacyMacro to mark legacy methods where they are
665 // declared in their class. Example usage:
666 //
667 // // \deprecated Replaced by MyOtherMethod() as of ITK 2.0.
668 // itkLegacyMacro(void MyMethod());
669 //
670 // See below for what to do for the method definition.
671 #if defined(ITK_LEGACY_REMOVE)
672 # define itkLegacyMacro(method) /* no ';' */
673 #else
674 # if defined(ITK_LEGACY_SILENT) || defined(ITK_LEGACY_TEST)
675 // Provide legacy methods with no warnings.
676 # define itkLegacyMacro(method) method
677 # else
678 // Request compile-time warnings for uses of deprecated methods.
679 # define itkLegacyMacro(method) [[deprecated]] method
680 # endif
681 #endif
682 
683 // Macros to create runtime deprecation warning messages in function
684 // bodies. Example usage:
685 //
686 // #if !defined( ITK_LEGACY_REMOVE )
687 // void itkMyClass::MyOldMethod()
688 // {
689 // itkLegacyBodyMacro(itkMyClass::MyOldMethod, 2.0);
690 // }
691 //
692 // void itkMyClass::MyMethod()
693 // {
694 // itkLegacyReplaceBodyMacro(itkMyClass::MyMethod, 2.0,
695 // itkMyClass::MyOtherMethod);
696 // }
697 // #endif
698 //
699 // NOTE: These 4 macros itkLegacyBodyMacro, itkLegacyReplaceBodyMacro,
700 // itkGenericLegacyBodyMacro, and itkGenericLegacyReplaceBodyMacro
701 // are purposefully not defined when ITK_LEGACY_REMOVE is on,
702 // because these macros are only relevant inside code segments
703 // that are conditionally compiled only when ITK_LEGACY_REMOVE
704 // is off.
705 #if defined(ITK_LEGACY_SILENT)
706 # define itkLegacyBodyMacro(method, version) ITK_NOOP_STATEMENT
707 # define itkLegacyReplaceBodyMacro(method, version, replace) ITK_NOOP_STATEMENT
708 # define itkGenericLegacyBodyMacro(method, version) ITK_NOOP_STATEMENT
709 # define itkGenericLegacyReplaceBodyMacro(method, version, replace) ITK_NOOP_STATEMENT
710 #else
711 # define itkLegacyBodyMacro(method, version) \
712  itkWarningMacro(#method " was deprecated for ITK " #version " and will be removed in a future version.")
713 # define itkLegacyReplaceBodyMacro(method, version, replace) \
714  itkWarningMacro(#method " was deprecated for ITK " #version \
715  " and will be removed in a future version. Use " #replace " instead.")
716 # define itkGenericLegacyBodyMacro(method, version) \
717  itkGenericOutputMacro(#method " was deprecated for ITK " #version " and will be removed in a future version.")
718 # define itkGenericLegacyReplaceBodyMacro(method, version, replace) \
719  itkGenericOutputMacro(#method " was deprecated for ITK " #version \
720  " and will be removed in a future version. Use " #replace " instead.")
721 #endif
722 
723 // Most modern x86 CPUs have 64 byte aligned blocks which are used for
724 // the cache lines. By aligning multi-threaded structures with the
725 // cache lines, false shared can be reduced, and performance
726 // increased.
727 #define ITK_CACHE_LINE_ALIGNMENT 64
728 
729 //
730 // itkPadStruct will add padding to a structure to ensure a minimum size
731 // for ensuring that adjacent structures do not share CACHE lines.
732 // Each struct will take up some multiple of cacheline sizes.
733 // This is particularly useful for arrays of thread private variables.
734 //
735 #define itkPadStruct(mincachesize, oldtype, newtype) \
736  struct newtype : public oldtype \
737  { \
738  char _StructPadding[mincachesize - (sizeof(oldtype) % mincachesize)]; \
739  };
740 
741 //
742 // itkAlignedTypedef is a macro which creates a new type to make a
743 // data structure aligned.
744 //
745 #if defined(ITK_HAS_GNU_ATTRIBUTE_ALIGNED)
746 # define itkAlignedTypedef(alignment, oldtype, newtype) using newtype = oldtype __attribute__((aligned(alignment)))
747 #elif defined(_MSC_VER)
748 # define itkAlignedTypedef(alignment, oldtype, newtype) using newtype = __declspec(align(alignment)) oldtype
749 #else
750 # define itkAlignedTypedef(alignment, oldtype, newtype) using newtype = oldtype
751 #endif
752 
753 #if defined(ITK_FUTURE_LEGACY_REMOVE)
754 //=============================================================================
755 /*
756 NOTE: DEPRECATED - This macro is not longer needed to support modern
757 compilers.
758 
759  Define a common way of declaring a templated function as a friend inside a class.
760  - ITK_FRIEND_TEMPLATE_FUNCTION_ARGUMENTS(T)
761 
762  The following templated function
763 
764  template <T>
765  T add(const T & a, const T & b);
766 
767  is declared as friend with
768 
769  class A
770  {
771  public:
772  friend Self add<>( const Self & a, const Self & b );
773  }
774 
775 */
776 # define ITK_FRIEND_TEMPLATE_FUNCTION_ARGUMENT(T) < >
777 #else // LEGACY_REMOVE
778 # define ITK_FRIEND_TEMPLATE_FUNCTION_ARGUMENT(T) "Macro remove use C++11 compliant declaration of "
779 #endif
780 
781 //--------------------------------------------------------------------------------
782 // Helper macros for Template Meta-Programming techniques of for-loops
783 // unrolling
784 //--------------------------------------------------------------------------------
785 
786 //--------------------------------------------------------------------------------
787 // Macro that generates an unrolled for loop for assigning elements of one array
788 // to elements of another array The array are assumed to be of same length
789 // (dimension), and this is also assumed to be the value of NumberOfIterations.
790 // No verification of size is performed. Casting is performed as part of the
791 // assignment, by using the DestinationElementType as the casting type.
792 // Source and destination array types must have defined operator[] in their
793 // API.
794 #define itkForLoopAssignmentMacro( \
795  DestinationType, SourceType, DestinationElementType, DestinationArray, SourceArray, NumberOfIterations) \
796  for (unsigned int i = 0; i < NumberOfIterations; ++i) \
797  { \
798  DestinationArray[i] = static_cast<DestinationElementType>(SourceArray[i]); \
799  }
800 
801 //--------------------------------------------------------------------------------
802 // Macro that generates an unrolled for loop for rounding and assigning
803 // elements of one array to elements of another array The array are assumed to
804 // be of same length (dimension), and this is also assumed to be the value of
805 // NumberOfIterations. No verification of size is performed. Casting is
806 // performed as part of the assignment, by using the DestinationElementType as
807 // the casting type.
808 // Source and destination array types must have defined operator[] in their
809 // API.
810 #define itkForLoopRoundingAndAssignmentMacro( \
811  DestinationType, Sourcrnd_halfintup, DestinationElementType, DestinationArray, SourceArray, NumberOfIterations) \
812  for (unsigned int i = 0; i < NumberOfIterations; ++i) \
813  { \
814  DestinationArray[i] = ::itk::Math::Round<DestinationElementType>(SourceArray[i]); \
815  }
816 
817 // end of Template Meta Programming helper macros
818 
819 #if !defined(NDEBUG) && !defined(ITK_WRAPPING)
820 
821 # ifdef __GLIBC__
822 # define itkAssertInDebugOrThrowInReleaseMacro(msg) __assert_fail(msg, __FILE__, __LINE__, __ASSERT_FUNCTION);
823 # else
824 # define itkAssertInDebugOrThrowInReleaseMacro(msg) itkGenericExceptionMacro(<< msg);
825 # endif
826 
827 #else
828 # define itkAssertInDebugOrThrowInReleaseMacro(msg) itkGenericExceptionMacro(<< msg);
829 #endif
830 
831 #define itkAssertOrThrowMacro(test, message) \
832  if (!(test)) \
833  { \
834  std::ostringstream msgstr; \
835  msgstr << message; \
836  itkAssertInDebugOrThrowInReleaseMacro(msgstr.str().c_str()); \
837  } \
838  ITK_MACROEND_NOOP_STATEMENT
839 
840 #if !defined(NDEBUG) && !defined(ITK_WRAPPING)
841 # define itkAssertInDebugAndIgnoreInReleaseMacro(X) assert(X)
842 #else
843 # define itkAssertInDebugAndIgnoreInReleaseMacro(X) ITK_NOOP_STATEMENT
844 #endif
845 
846 
847 // !!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!
848 // !!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!
849 // !! The ITK Get/Set Macros for various types !!
850 // !!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!
851 // !!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!
852 
853 #ifdef ITK_FUTURE_LEGACY_REMOVE
854 # define itkStaticConstMacro(name, type, value) \
855  "Replace itkStaticConstMacro(name, type, value) with `static constexpr type name = value`"
856 # define itkGetStaticConstMacro(name) "Replace itkGetStaticConstMacro(name) with `Self::name`"
857 #else
858 
872 # define itkStaticConstMacro(name, type, value) static constexpr type name = value
873 
874 # define itkGetStaticConstMacro(name) (Self::name)
875 #endif
876 
878 #define itkSetInputMacro(name, type) \
879  virtual void Set##name(const type * _arg) \
880  { \
881  itkDebugMacro("setting input " #name " to " << _arg); \
882  if (_arg != itkDynamicCastInDebugMode<type *>(this->ProcessObject::GetInput(#name))) \
883  { \
884  this->ProcessObject::SetInput(#name, const_cast<type *>(_arg)); \
885  this->Modified(); \
886  } \
887  } \
888  ITK_MACROEND_NOOP_STATEMENT
889 
892 #define itkGetInputMacro(name, type) \
893  virtual const type * Get##name() const \
894  { \
895  itkDebugMacro("returning input " << #name " of " << this->ProcessObject::GetInput(#name)); \
896  return itkDynamicCastInDebugMode<const type *>(this->ProcessObject::GetInput(#name)); \
897  } \
898  ITK_MACROEND_NOOP_STATEMENT
899 
901 // clang-format off
903 #define itkSetDecoratedInputMacro(name, type) \
904  virtual void Set##name##Input(const SimpleDataObjectDecorator<type> * _arg) \
905  { \
906  itkDebugMacro("setting input " #name " to " << _arg); \
907  if (_arg != itkDynamicCastInDebugMode<SimpleDataObjectDecorator<type> *>(this->ProcessObject::GetInput(#name))) \
908  { \
909  this->ProcessObject::SetInput(#name, const_cast<SimpleDataObjectDecorator<type> *>(_arg)); \
910  this->Modified(); \
911  } \
912  } \
913  virtual void Set##name(const SimpleDataObjectDecorator<type> * _arg) { this->Set##name##Input(_arg); } \
914  virtual void Set##name(const type & _arg) \
915  { \
916  using DecoratorType = SimpleDataObjectDecorator<type>; \
917  itkDebugMacro("setting input " #name " to " << _arg); \
918  const DecoratorType * oldInput = \
919  itkDynamicCastInDebugMode<const DecoratorType *>(this->ProcessObject::GetInput(#name)); \
920  ITK_GCC_PRAGMA_PUSH \
921  ITK_GCC_SUPPRESS_Wfloat_equal \
922  if (oldInput && oldInput->Get() == _arg) \
923  { \
924  return; \
925  } \
926  ITK_GCC_PRAGMA_POP \
927  auto newInput = DecoratorType::New(); \
928  newInput->Set(_arg); \
929  this->Set##name##Input(newInput); \
930  } \
931  ITK_MACROEND_NOOP_STATEMENT
932 // clang-format on
936 #define itkGetDecoratedInputMacro(name, type) \
937  virtual const SimpleDataObjectDecorator<type> * Get##name##Input() const \
938  { \
939  itkDebugMacro("returning input " << #name " of " << this->ProcessObject::GetInput(#name)); \
940  return itkDynamicCastInDebugMode<const SimpleDataObjectDecorator<type> *>(this->ProcessObject::GetInput(#name)); \
941  } \
942  virtual const type & Get##name() const \
943  { \
944  itkDebugMacro("Getting input " #name); \
945  using DecoratorType = SimpleDataObjectDecorator<type>; \
946  const DecoratorType * input = \
947  itkDynamicCastInDebugMode<const DecoratorType *>(this->ProcessObject::GetInput(#name)); \
948  if (input == nullptr) \
949  { \
950  itkExceptionMacro("input" #name " is not set"); \
951  } \
952  return input->Get(); \
953  } \
954  ITK_MACROEND_NOOP_STATEMENT
955 
959 #define itkSetGetDecoratedInputMacro(name, type) \
960  itkSetDecoratedInputMacro(name, type); \
961  itkGetDecoratedInputMacro(name, type)
962 
967 #define itkSetDecoratedObjectInputMacro(name, type) \
968  virtual void Set##name##Input(const DataObjectDecorator<type> * _arg) \
969  { \
970  itkDebugMacro("setting input " #name " to " << _arg); \
971  if (_arg != itkDynamicCastInDebugMode<DataObjectDecorator<type> *>(this->ProcessObject::GetInput(#name))) \
972  { \
973  this->ProcessObject::SetInput(#name, const_cast<DataObjectDecorator<type> *>(_arg)); \
974  this->Modified(); \
975  } \
976  } \
977  virtual void Set##name(const type * _arg) \
978  { \
979  using DecoratorType = DataObjectDecorator<type>; \
980  itkDebugMacro("setting input " #name " to " << _arg); \
981  const DecoratorType * oldInput = \
982  itkDynamicCastInDebugMode<const DecoratorType *>(this->ProcessObject::GetInput(#name)); \
983  if (oldInput && oldInput->Get() == _arg) \
984  { \
985  return; \
986  } \
987  auto newInput = DecoratorType::New(); \
988  newInput->Set(_arg); \
989  this->Set##name##Input(newInput); \
990  } \
991  ITK_MACROEND_NOOP_STATEMENT
992 
998 #define itkGetDecoratedObjectInputMacro(name, type) \
999  virtual const DataObjectDecorator<type> * Get##name##Input() const \
1000  { \
1001  itkDebugMacro("returning input " << #name " of " << this->ProcessObject::GetInput(#name)); \
1002  return itkDynamicCastInDebugMode<const DataObjectDecorator<type> *>(this->ProcessObject::GetInput(#name)); \
1003  } \
1004  virtual const type * Get##name() const \
1005  { \
1006  itkDebugMacro("Getting input " #name); \
1007  using DecoratorType = DataObjectDecorator<type>; \
1008  const DecoratorType * input = \
1009  itkDynamicCastInDebugMode<const DecoratorType *>(this->ProcessObject::GetInput(#name)); \
1010  if (input == nullptr) \
1011  { \
1012  return nullptr; \
1013  } \
1014  return input->Get(); \
1015  } \
1016  ITK_MACROEND_NOOP_STATEMENT
1017 
1021 #define itkSetGetDecoratedObjectInputMacro(name, type) \
1022  itkSetDecoratedObjectInputMacro(name, type); \
1023  itkGetDecoratedObjectInputMacro(name, type)
1024 
1026 // clang-format off
1027 #define itkSetMacro(name, type) \
1028  virtual void Set##name(type _arg) \
1029  { \
1030  itkDebugMacro("setting " #name " to " << _arg); \
1031  ITK_GCC_PRAGMA_PUSH \
1032  ITK_GCC_SUPPRESS_Wfloat_equal \
1033  if (this->m_##name != _arg) \
1034  { \
1035  this->m_##name = std::move(_arg); \
1036  this->Modified(); \
1037  } \
1038  ITK_GCC_PRAGMA_POP \
1039  } \
1040  ITK_MACROEND_NOOP_STATEMENT
1041 // clang-format on
1042 
1044 #define itkGetMacro(name, type) \
1045  virtual type Get##name() { return this->m_##name; } \
1046  ITK_MACROEND_NOOP_STATEMENT
1047 
1052 #define itkGetConstMacro(name, type) \
1053  virtual type Get##name() const { return this->m_##name; } \
1054  ITK_MACROEND_NOOP_STATEMENT
1055 
1061 #define itkGetConstReferenceMacro(name, type) \
1062  virtual const type & Get##name() const { return this->m_##name; } \
1063  ITK_MACROEND_NOOP_STATEMENT
1064 
1070 #define itkSetEnumMacro(name, type) \
1071  virtual void Set##name(const type _arg) \
1072  { \
1073  itkDebugMacro("setting " #name " to " << static_cast<long>(_arg)); \
1074  if (this->m_##name != _arg) \
1075  { \
1076  this->m_##name = _arg; \
1077  this->Modified(); \
1078  } \
1079  } \
1080  ITK_MACROEND_NOOP_STATEMENT
1081 
1087 #define itkGetEnumMacro(name, type) \
1088  virtual type Get##name() const { return this->m_##name; } \
1089  ITK_MACROEND_NOOP_STATEMENT
1090 
1095 #define itkSetStringMacro(name) \
1096  virtual void Set##name(const char * _arg) \
1097  { \
1098  if (_arg && (_arg == this->m_##name)) \
1099  { \
1100  return; \
1101  } \
1102  if (_arg) \
1103  { \
1104  this->m_##name = _arg; \
1105  } \
1106  else \
1107  { \
1108  this->m_##name = ""; \
1109  } \
1110  this->Modified(); \
1111  } \
1112  virtual void Set##name(const std::string & _arg) { this->Set##name(_arg.c_str()); } \
1113  ITK_MACROEND_NOOP_STATEMENT
1114 
1120 #define itkGetStringMacro(name) \
1121  virtual const char * Get##name() const { return this->m_##name.c_str(); } \
1122  ITK_MACROEND_NOOP_STATEMENT
1123 
1124 // clang-format off
1128 #define itkSetClampMacro(name, type, min, max) \
1129  virtual void Set##name(type _arg) \
1130  { \
1131  const type temp_extrema = (_arg <= min ? min : (_arg >= max ? max : _arg)); \
1132  itkDebugMacro("setting " << #name " to " << _arg); \
1133  ITK_GCC_PRAGMA_PUSH \
1134  ITK_GCC_SUPPRESS_Wfloat_equal \
1135  if (this->m_##name != temp_extrema) \
1136  { \
1137  this->m_##name = temp_extrema; \
1138  this->Modified(); \
1139  } \
1140  ITK_GCC_PRAGMA_POP \
1141  } \
1142  ITK_MACROEND_NOOP_STATEMENT
1143 // clang-format on
1146 // clang-format off
1150 #define itkSetObjectMacro(name, type) \
1151  virtual void Set##name(type * _arg) \
1152  { \
1153  itkDebugMacro("setting " << #name " to " << _arg); \
1154  if (this->m_##name != _arg) \
1155  { \
1156  this->m_##name = _arg; \
1157  this->Modified(); \
1158  } \
1159  } \
1160  ITK_MACROEND_NOOP_STATEMENT
1161 // clang-format on
1172 // NOTE: A class can use either itkGetModifiableObjectMacro
1173 // or itkGetObjectMacro, but not both.
1174 // A class can use either itkGetModifiableObjectMacro
1175 // or itkGetConstObjectMacro, but not both.
1176 // If the desired behavior is to only provide const
1177 // access to the itkObject ivar, then use itkGetConstObjectMacro,
1178 // else use itkGetModifiableObjectMacro for read/write access to
1179 // the ivar.
1180 // It is permissible to use both itkGetObjectMacro and itkGetConstObjectMacro
1181 // for backwards compatibility.
1182 // If the ITK_LEGACY_REMOVE=FALSE, then it is
1183 // permissible to use itkGetObjectMacro which
1184 // defines both signatures itk::GetXXX() and
1185 // itk::GetModifiableXXX()
1186 
1189 #define itkGetConstObjectMacro(name, type) \
1190  virtual const type * Get##name() const { return this->m_##name.GetPointer(); } \
1191  ITK_MACROEND_NOOP_STATEMENT
1192 
1193 
1194 #if defined(ITK_FUTURE_LEGACY_REMOVE)
1195 // In the future, the itkGetObjectMacro will be deprecated with the ITK_LEGACY_REMOVE
1196 // flag. For now, this very advanced feature is only available
1197 // through manual setting of a compiler define -DITK_FUTURE_LEGACY_REMOVE
1198 // ("/DITK_FUTURE_LEGACY_REMOVE /EHsc" with Visual Studio)
1199 // to ease the transition from the historical GetObjectMacro to the GetModifiableObjectMacro
1200 # define itkGetObjectMacro(name, type) \
1201  virtual type * Get##name() \
1202  { \
1203  purposeful_error("itkGetObjectMacro should be replaced with itkGetModifiableObjectMacro."); \
1204  }
1205 
1206 # define itkGetModifiableObjectMacro(name, type) \
1207  virtual type * GetModifiable##name() { return this->m_##name.GetPointer(); } \
1208  itkGetConstObjectMacro(name, type)
1209 
1210 #else // defined ( ITK_FUTURE_LEGACY_REMOVE )
1211 
1213 # define itkGetObjectMacro(name, type) \
1214  virtual type * Get##name() { return this->m_##name.GetPointer(); } \
1215  ITK_MACROEND_NOOP_STATEMENT
1216 # define itkGetModifiableObjectMacro(name, type) \
1217  virtual type * GetModifiable##name() { return this->m_##name.GetPointer(); } \
1218  itkGetConstObjectMacro(name, type); \
1219  itkGetObjectMacro(name, type)
1220 #endif // defined ( ITK_FUTURE_LEGACY_REMOVE )
1221 
1223 // For backwards compatibility define ITK_EXPORT to nothing
1224 #define ITK_EXPORT
1225 
1226 
1229 #define itkGetConstReferenceObjectMacro(name, type) \
1230  virtual const typename type::Pointer & Get##name() const { return this->m_##name; } \
1231  ITK_MACROEND_NOOP_STATEMENT
1232 
1236 #define itkSetConstObjectMacro(name, type) \
1237  virtual void Set##name(const type * _arg) \
1238  { \
1239  itkDebugMacro("setting " << #name " to " << _arg); \
1240  if (this->m_##name != _arg) \
1241  { \
1242  this->m_##name = _arg; \
1243  this->Modified(); \
1244  } \
1245  } \
1246  ITK_MACROEND_NOOP_STATEMENT
1247 
1251 #define itkBooleanMacro(name) \
1252  virtual void name##On() { this->Set##name(true); } \
1253  virtual void name##Off() { this->Set##name(false); }
1254 
1256 // clang-format off
1260 #define itkSetVectorMacro(name, type, count) \
1261  virtual void Set##name(type data[]) \
1262  { \
1263  unsigned int i; \
1264  for (i = 0; i < count; ++i) \
1265  { \
1266  ITK_GCC_PRAGMA_PUSH \
1267  ITK_GCC_SUPPRESS_Wfloat_equal \
1268  if (data[i] != this->m_##name[i]) \
1269  { \
1270  break; \
1271  } \
1272  ITK_GCC_PRAGMA_POP \
1273  } \
1274  if (i < count) \
1275  { \
1276  this->Modified(); \
1277  for (i = 0; i < count; ++i) \
1278  { \
1279  this->m_##name[i] = data[i]; \
1280  } \
1281  } \
1282  } \
1283  ITK_MACROEND_NOOP_STATEMENT
1284 // clang-format on
1289 #define itkGetVectorMacro(name, type, count) \
1290  virtual type * Get##name() const { return this->m_##name; } \
1291  ITK_MACROEND_NOOP_STATEMENT
1292 
1297 #define itkGPUKernelClassMacro(kernel) class itkGPUKernelMacro(kernel)
1298 
1304 #define itkGPUKernelMacro(kernel) \
1305  kernel \
1306  { \
1307  public: \
1308  ITK_DISALLOW_COPY_AND_MOVE(kernel); \
1309  kernel() = delete; \
1310  ~kernel() = delete; \
1311  static const char * GetOpenCLSource(); \
1312  }
1313 
1315 #define itkGetOpenCLSourceFromKernelMacro(kernel) \
1316  static const char * GetOpenCLSource() { return kernel::GetOpenCLSource(); }
1317 
1318 // A useful macro in the PrintSelf method for printing member variables
1319 // which are pointers to object based on the LightObject class.
1320 #define itkPrintSelfObjectMacro(name) \
1321  if (static_cast<const LightObject *>(this->m_##name) == nullptr) \
1322  { \
1323  os << indent << #name << ": (null)" << std::endl; \
1324  } \
1325  else \
1326  { \
1327  os << indent << #name << ": " << std::endl; \
1328  this->m_##name->Print(os, indent.GetNextIndent()); \
1329  } \
1330  ITK_MACROEND_NOOP_STATEMENT
1331 
1332 
1334 #define itkSetDecoratedOutputMacro(name, type) \
1335  virtual void Set##name##Output(const SimpleDataObjectDecorator<type> * _arg) \
1336  { \
1337  itkDebugMacro("setting output " #name " to " << _arg); \
1338  if (_arg != itkDynamicCastInDebugMode<SimpleDataObjectDecorator<type> *>(this->ProcessObject::GetOutput(#name))) \
1339  { \
1340  this->ProcessObject::SetOutput(#name, const_cast<SimpleDataObjectDecorator<type> *>(_arg)); \
1341  this->Modified(); \
1342  } \
1343  } \
1344  virtual void Set##name(const type & _arg) \
1345  { \
1346  using DecoratorType = SimpleDataObjectDecorator<type>; \
1347  itkDebugMacro("setting output " #name " to " << _arg); \
1348  DecoratorType * output = itkDynamicCastInDebugMode<DecoratorType *>(this->ProcessObject::GetOutput(#name)); \
1349  if (output) \
1350  { \
1351  if (output->Get() == _arg) \
1352  { \
1353  return; \
1354  } \
1355  else \
1356  { \
1357  output->Set(_arg); \
1358  } \
1359  } \
1360  else \
1361  { \
1362  auto newOutput = DecoratorType::New(); \
1363  newOutput->Set(_arg); \
1364  this->Set##name##Output(newOutput); \
1365  } \
1366  } \
1367  ITK_MACROEND_NOOP_STATEMENT
1368 
1371 #define itkGetDecoratedOutputMacro(name, type) \
1372  virtual const SimpleDataObjectDecorator<type> * Get##name##Output() const \
1373  { \
1374  itkDebugMacro("returning output " << #name " of " << this->ProcessObject::GetOutput(#name)); \
1375  return itkDynamicCastInDebugMode<const SimpleDataObjectDecorator<type> *>(this->ProcessObject::GetOutput(#name)); \
1376  } \
1377  virtual const type & Get##name() const \
1378  { \
1379  itkDebugMacro("Getting output " #name); \
1380  using DecoratorType = SimpleDataObjectDecorator<type>; \
1381  const DecoratorType * output = \
1382  itkDynamicCastInDebugMode<const DecoratorType *>(this->ProcessObject::GetOutput(#name)); \
1383  if (output == nullptr) \
1384  { \
1385  itkExceptionMacro("output" #name " is not set"); \
1386  } \
1387  return output->Get(); \
1388  } \
1389  ITK_MACROEND_NOOP_STATEMENT
1390 
1402 #if defined(ITKV4_COMPATIBILITY)
1403 # define ITK_ITERATOR_VIRTUAL virtual
1404 # define ITK_ITERATOR_OVERRIDE override
1405 # define ITK_ITERATOR_FINAL
1406 #elif !defined(ITK_LEGACY_REMOVE)
1407 # define ITK_ITERATOR_VIRTUAL virtual
1408 # define ITK_ITERATOR_OVERRIDE override
1409 # define ITK_ITERATOR_FINAL final
1410 #else
1411 # define ITK_ITERATOR_VIRTUAL
1412 # define ITK_ITERATOR_OVERRIDE
1413 # define ITK_ITERATOR_FINAL
1414 #endif
1415 
1416 #if defined(ITKV4_COMPATIBILITY)
1417 // A macro for methods which are const in ITKv5, but not in ITKv4
1418 # define ITKv5_CONST
1419 #else
1420 // A macro for methods which are const in ITKv5, but not in ITKv4
1421 # define ITKv5_CONST const
1422 #endif
1423 
1424 #define itkExceptionObject_h
1425 #include "itkExceptionObject.h"
1426 #undef itkExceptionObject_h
1427 
1435 template <typename TTarget, typename TSource>
1436 TTarget
1437 itkDynamicCastInDebugMode(TSource x)
1438 {
1439 #ifndef NDEBUG
1440  if (x == nullptr)
1441  {
1442  return nullptr;
1443  }
1444  TTarget rval = dynamic_cast<TTarget>(x);
1445  if (rval == nullptr)
1446  {
1447  itkGenericExceptionMacro("Failed dynamic cast to " << typeid(TTarget).name()
1448  << " object type = " << x->GetNameOfClass());
1449  }
1450  return rval;
1451 #else
1452  return static_cast<TTarget>(x);
1453 #endif
1454 }
1457 #ifdef ITK_LEGACY_REMOVE
1458 # if __cplusplus >= 202002L
1459 # define ITK_NODISCARD(message) [[nodiscard(message)]]
1460 # else
1461 # define ITK_NODISCARD(message) [[nodiscard]]
1462 # endif
1463 #else
1464 # define ITK_NODISCARD(message)
1465 #endif
1466 
1467 // Defines which used to be in itk_compiler_detection.h
1468 #define ITK_ALIGNAS(X) alignas(X)
1469 #define ITK_ALIGNOF(X) alignof(X)
1470 #define ITK_DEPRECATED [[deprecated]]
1471 #define ITK_DEPRECATED_MSG(MSG) [[deprecated(MSG)]]
1472 #define ITK_CONSTEXPR constexpr
1473 #define ITK_DELETED_FUNCTION = delete
1474 #define ITK_EXTERN_TEMPLATE extern
1475 #define ITK_FINAL final
1476 #define ITK_NOEXCEPT noexcept
1477 #define ITK_NOEXCEPT_EXPR(X) noexcept(X)
1478 #define ITK_NULLPTR nullptr
1479 #define ITK_OVERRIDE override
1480 #define ITK_STATIC_ASSERT(X) static_assert(X, #X)
1481 #define ITK_STATIC_ASSERT_MSG(X, MSG) static_assert(X, MSG)
1482 #define ITK_THREAD_LOCAL thread_local
1483 
1484 #endif // end of itkMacro.h
itkPrintHelper.h
itkExceptionObject.h
itkWin32Header.h
itk
The "itk" namespace contains all Insight Segmentation and Registration Toolkit (ITK) classes....
Definition: itkAnnulusOperator.h:24
Tarballs of the nightly generated Doxygen documentation are available for the html, xml, and tag file. Previous versions of this documentation for version: 5.3, 5.2, 5.1, 5.0, 4.13, 3.20.
Generated on unknown for ITK by   doxygen 1.8.16