/usr/include/ITK-4.5/itkMacro.h is in libinsighttoolkit4-dev 4.5.0-3.
This file is owned by root:root, with mode 0o644.
The actual contents of the file can be viewed below.
1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 31 32 33 34 35 36 37 38 39 40 41 42 43 44 45 46 47 48 49 50 51 52 53 54 55 56 57 58 59 60 61 62 63 64 65 66 67 68 69 70 71 72 73 74 75 76 77 78 79 80 81 82 83 84 85 86 87 88 89 90 91 92 93 94 95 96 97 98 99 100 101 102 103 104 105 106 107 108 109 110 111 112 113 114 115 116 117 118 119 120 121 122 123 124 125 126 127 128 129 130 131 132 133 134 135 136 137 138 139 140 141 142 143 144 145 146 147 148 149 150 151 152 153 154 155 156 157 158 159 160 161 162 163 164 165 166 167 168 169 170 171 172 173 174 175 176 177 178 179 180 181 182 183 184 185 186 187 188 189 190 191 192 193 194 195 196 197 198 199 200 201 202 203 204 205 206 207 208 209 210 211 212 213 214 215 216 217 218 219 220 221 222 223 224 225 226 227 228 229 230 231 232 233 234 235 236 237 238 239 240 241 242 243 244 245 246 247 248 249 250 251 252 253 254 255 256 257 258 259 260 261 262 263 264 265 266 267 268 269 270 271 272 273 274 275 276 277 278 279 280 281 282 283 284 285 286 287 288 289 290 291 292 293 294 295 296 297 298 299 300 301 302 303 304 305 306 307 308 309 310 311 312 313 314 315 316 317 318 319 320 321 322 323 324 325 326 327 328 329 330 331 332 333 334 335 336 337 338 339 340 341 342 343 344 345 346 347 348 349 350 351 352 353 354 355 356 357 358 359 360 361 362 363 364 365 366 367 368 369 370 371 372 373 374 375 376 377 378 379 380 381 382 383 384 385 386 387 388 389 390 391 392 393 394 395 396 397 398 399 400 401 402 403 404 405 406 407 408 409 410 411 412 413 414 415 416 417 418 419 420 421 422 423 424 425 426 427 428 429 430 431 432 433 434 435 436 437 438 439 440 441 442 443 444 445 446 447 448 449 450 451 452 453 454 455 456 457 458 459 460 461 462 463 464 465 466 467 468 469 470 471 472 473 474 475 476 477 478 479 480 481 482 483 484 485 486 487 488 489 490 491 492 493 494 495 496 497 498 499 500 501 502 503 504 505 506 507 508 509 510 511 512 513 514 515 516 517 518 519 520 521 522 523 524 525 526 527 528 529 530 531 532 533 534 535 536 537 538 539 540 541 542 543 544 545 546 547 548 549 550 551 552 553 554 555 556 557 558 559 560 561 562 563 564 565 566 567 568 569 570 571 572 573 574 575 576 577 578 579 580 581 582 583 584 585 586 587 588 589 590 591 592 593 594 595 596 597 598 599 600 601 602 603 604 605 606 607 608 609 610 611 612 613 614 615 616 617 618 619 620 621 622 623 624 625 626 627 628 629 630 631 632 633 634 635 636 637 638 639 640 641 642 643 644 645 646 647 648 649 650 651 652 653 654 655 656 657 658 659 660 661 662 663 664 665 666 667 668 669 670 671 672 673 674 675 676 677 678 679 680 681 682 683 684 685 686 687 688 689 690 691 692 693 694 695 696 697 698 699 700 701 702 703 704 705 706 707 708 709 710 711 712 713 714 715 716 717 718 719 720 721 722 723 724 725 726 727 728 729 730 731 732 733 734 735 736 737 738 739 740 741 742 743 744 745 746 747 748 749 750 751 752 753 754 755 756 757 758 759 760 761 762 763 764 765 766 767 768 769 770 771 772 773 774 775 776 777 778 779 780 781 782 783 784 785 786 787 788 789 790 791 792 793 794 795 796 797 798 799 800 801 802 803 804 805 806 807 808 809 810 811 812 813 814 815 816 817 818 819 820 821 822 823 824 825 826 827 828 829 830 831 832 833 834 835 836 837 838 839 840 841 842 843 844 845 846 847 848 849 850 851 852 853 854 855 856 857 858 859 860 861 862 863 864 865 866 867 868 869 870 871 872 873 874 875 876 877 878 879 880 881 882 883 884 885 886 887 888 889 890 891 892 893 894 895 896 897 898 899 900 901 902 903 904 905 906 907 908 909 910 911 912 913 914 915 916 917 918 919 920 921 922 923 924 925 926 927 928 929 930 931 932 933 934 935 936 937 938 939 940 941 942 943 944 945 946 947 948 949 950 951 952 953 954 955 956 957 958 959 960 961 962 963 964 965 966 967 968 969 970 971 972 973 974 975 976 977 978 979 980 981 982 983 984 985 986 987 988 989 990 991 992 993 994 995 996 997 998 999 1000 1001 1002 1003 1004 1005 1006 1007 1008 1009 1010 1011 1012 1013 1014 1015 1016 1017 1018 1019 1020 1021 1022 1023 1024 1025 1026 1027 1028 1029 1030 1031 1032 1033 1034 1035 1036 1037 1038 1039 1040 1041 1042 1043 1044 1045 1046 1047 1048 1049 1050 1051 1052 1053 1054 1055 1056 1057 1058 1059 1060 1061 1062 1063 1064 1065 1066 1067 1068 1069 1070 1071 1072 1073 1074 1075 1076 1077 1078 1079 1080 1081 1082 1083 1084 1085 1086 1087 1088 1089 1090 1091 1092 1093 1094 1095 1096 1097 1098 1099 1100 1101 1102 1103 1104 1105 1106 1107 1108 1109 1110 1111 1112 1113 1114 1115 1116 1117 1118 1119 1120 1121 1122 1123 1124 1125 1126 1127 1128 1129 1130 1131 1132 1133 1134 1135 1136 1137 1138 1139 1140 1141 1142 | /*=========================================================================
*
* Copyright Insight Software Consortium
*
* 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
*
* http://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.
*
*=========================================================================*/
/**
* itkMacro.h defines standard system-wide macros, constants, and other
* parameters. One of its most important functions is to define macros used
* to interface to instance variables in a standard fashion. For example,
* these macros manage modified time, debugging information, and provide a
* standard interface to set and get instance variables. Macros are
* available for built-in types; for string classe; vector arrays;
* object pointers; and debug, warning, and error printout information.
*/
#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>
/** \namespace itk
* \brief The "itk" namespace contains all Insight Segmentation and
* Registration Toolkit (ITK) classes. There are several nested namespaces
* within the itk:: namespace. */
namespace itk
{
// end namespace itk - this is here for documentation purposes
}
/** A convenience macro marks variables as not being used by a method,
* avoiding compile-time warnings. */
#define itkNotUsed(x)
/*
* ITK only supports MSVC++ 7.1 and greater
* MSVC++ 11.0 _MSC_VER = 1700
* MSVC++ 10.0 _MSC_VER = 1600
* MSVC++ 9.0 _MSC_VER = 1500
* MSVC++ 8.0 _MSC_VER = 1400
* MSVC++ 7.1 _MSC_VER = 1310
* MSVC++ 7.0 _MSC_VER = 1300
* MSVC++ 6.0 _MSC_VER = 1200
* MSVC++ 5.0 _MSC_VER = 1100
*/
#if defined( _MSC_VER ) && ( _MSC_VER < 1310 )
//#error "_MSC_VER < 1310 (MSVC++ 7.1) not supported under ITKv4"
#endif
#if defined( __SUNPRO_CC ) && ( __SUNPRO_CC < 0x590 )
#error "__SUNPRO_CC < 0x590 not supported under ITKv4"
#endif
#if defined( __CYGWIN__ )
#error "The Cygwin compiler is not supported in ITKv4 and above"
#endif
#if defined( __BORLANDC__ )
#error "The Borland C compiler is not supported in ITKv4 and above"
#endif
#if defined( __MWERKS__ )
#error "The MetroWerks compiler is not supported in ITKv4 and above"
#endif
#if defined( __GNUC__ ) && ( __GNUC__ < 3 )
#error "The __GNUC__ version 2.95 compiler is not supprted under ITKv4 and above"
#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 supprted under ITKv4 and above"
#endif
#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
#if __GNUC__ >= 4
#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
/** Define two object creation methods. The first method, New(),
* creates an object from a class, potentially deferring to a factory.
* The second method, CreateAnother(), creates an object from an
* instance, potentially deferring to a factory. This second method
* allows you to create an instance of an object that is exactly the
* same type as the referring object. This is useful in cases where
* an object has been cast back to a base class.
*
* These creation methods first try asking the object factory to create
* an instance, and then default to the standard "new" operator if the
* factory fails.
*
* These routines assigns the raw pointer to a smart pointer and then call
* UnRegister() on the rawPtr to compensate for LightObject's constructor
* initializing an object's reference count to 1 (needed for proper
* initialization of process objects and data objects cycles).
*
* Break the methods into itkSimpleNewMacro and itkCreateAnotherMacro
* so we can selectively overload CreateAnother() without having to
* provide a definition for New(). */
#define itkNewMacro(x) \
itkSimpleNewMacro(x) \
itkCreateAnotherMacro(x) \
itkCloneMacro(x)
#define itkSimpleNewMacro(x) \
static Pointer New(void) \
{ \
Pointer smartPtr = ::itk::ObjectFactory< x >::Create(); \
if ( smartPtr.GetPointer() == NULL ) \
{ \
smartPtr = new x; \
} \
smartPtr->UnRegister(); \
return smartPtr; \
}
#define itkCreateAnotherMacro(x) \
virtual::itk::LightObject::Pointer CreateAnother(void) const \
{ \
::itk::LightObject::Pointer smartPtr; \
smartPtr = x::New().GetPointer(); \
return smartPtr; \
}
#define itkCloneMacro(x) \
Pointer Clone() const \
{ \
Pointer rval = \
dynamic_cast<x *>(this->InternalClone().GetPointer()); \
return rval; \
}
/** Define two object creation methods. The first method, New(),
* creates an object from a class but does not defer to a factory.
* The second method, CreateAnother(), creates an object from an
* instance, again without deferring to a factory. This second method
* allows you to create an instance of an object that is exactly the
* same type as the referring object. This is useful in cases where
* an object has been cast back to a base class.
*
* These creation methods first try asking the object factory to create
* an instance, and then default to the standard "new" operator if the
* factory fails.
*
* These routines assigns the raw pointer to a smart pointer and then call
* UnRegister() on the rawPtr to compensate for LightObject's constructor
* initializing an object's reference count to 1 (needed for proper
* initialization of process objects and data objects cycles). */
#define itkFactorylessNewMacro(x) \
static Pointer New(void) \
{ \
Pointer smartPtr; \
x * rawPtr = new x; \
smartPtr = rawPtr; \
rawPtr->UnRegister(); \
return smartPtr; \
} \
virtual::itk::LightObject::Pointer CreateAnother(void) const \
{ \
::itk::LightObject::Pointer smartPtr; \
smartPtr = x::New().GetPointer(); \
return smartPtr; \
}
/** Macro used to add standard methods to all classes, mainly type
* information. */
#define itkTypeMacro(thisClass, superclass) \
virtual const char *GetNameOfClass() const \
{ \
return #thisClass; \
}
namespace itk
{
/**
* The following is used to output debug, warning, and error messages.
* Use a global function which actually calls:
* OutputWindow::GetInstance()->DisplayText();
* This is to avoid Object \#include of OutputWindow
* while OutputWindow \#includes Object. */
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 *);
} // end namespace itk
/** This macro is used to print debug (or other information). They are
* also used to catch errors, etc. Example usage looks like:
* itkDebugMacro(<< "this is debug info" << this->SomeVariable); */
#if defined( NDEBUG )
#define itkDebugMacro(x)
#define itkDebugStatement(x)
#else
#define itkDebugMacro(x) \
{ \
if ( this->GetDebug() && ::itk::Object::GetGlobalWarningDisplay() ) \
{ \
std::ostringstream itkmsg; \
itkmsg << "Debug: In " __FILE__ ", line " << __LINE__ << "\n" \
<< this->GetNameOfClass() << " (" << this << "): " x \
<< "\n\n"; \
::itk::OutputWindowDisplayDebugText( itkmsg.str().c_str() ); \
} \
}
//The itkDebugStatement is to be used to protect code that is only
//used in the itkDebugMacro
#define itkDebugStatement(x) x
#endif
/** This macro is used to print warning information (i.e., unusual circumstance
* but not necessarily fatal.) Example usage looks like:
* itkWarningMacro(<< "this is warning info" << this->SomeVariable); */
#define itkWarningMacro(x) \
{ \
if ( ::itk::Object::GetGlobalWarningDisplay() ) \
{ \
std::ostringstream itkmsg; \
itkmsg << "WARNING: In " __FILE__ ", line " << __LINE__ << "\n" \
<< this->GetNameOfClass() << " (" << this << "): " x \
<< "\n\n"; \
::itk::OutputWindowDisplayWarningText( itkmsg.str().c_str() ); \
} \
}
//The itkDebugStatement is to be used ot protect code that is only
//used in the itkDebugMacro
#define itkWarningStatement(x) x
#if defined( ITK_CPP_FUNCTION )
#if defined( _WIN32 ) && !defined( __MINGW32__ ) && !defined( CABLE_CONFIGURATION ) \
&& !defined( CSWIG )
#define ITK_LOCATION __FUNCSIG__
#elif defined( __GNUC__ )
#define ITK_LOCATION __PRETTY_FUNCTION__
#else
#define ITK_LOCATION __FUNCTION__
#endif
#else
#define ITK_LOCATION "unknown"
#endif
#include "itkExceptionObject.h"
/** The exception macro is used to print error information (i.e., usually
* a condition that results in program failure). Example usage looks like:
* itkExceptionMacro(<< "this is error info" << this->SomeVariable); */
#define itkExceptionMacro(x) \
{ \
std::ostringstream message; \
message << "itk::ERROR: " << this->GetNameOfClass() \
<< "(" << this << "): " x; \
::itk::ExceptionObject e_(__FILE__, __LINE__, message.str().c_str(), ITK_LOCATION); \
throw e_; /* Explicit naming to work around Intel compiler bug. */ \
}
#define itkGenericExceptionMacro(x) \
{ \
std::ostringstream message; \
message << "itk::ERROR: " x; \
::itk::ExceptionObject e_(__FILE__, __LINE__, message.str().c_str(), ITK_LOCATION); \
throw e_; /* Explicit naming to work around Intel compiler bug. */ \
}
#define itkDeclareExceptionMacro(newexcp,parentexcp,whatmessage) \
namespace itk { \
class newexcp : public parentexcp \
{ \
public: \
newexcp( const char *file, unsigned int lineNumber ) : \
parentexcp( file, lineNumber ) \
{ \
this->SetDescription( whatmessage ); \
} \
newexcp( const std::string & file, unsigned int lineNumber ) : \
parentexcp( file, lineNumber ) \
{ \
this->SetDescription( whatmessage ); \
} \
itkTypeMacro(newexcp, parentexcp); \
}; \
}
#define itkSpecializedExceptionMacro(exceptiontype) \
{ \
::itk::exceptiontype e_(__FILE__, __LINE__); \
e_.SetLocation(ITK_LOCATION); \
throw e_; /* Explicit naming to work around Intel compiler bug. */ \
}
#define itkSpecializedMessageExceptionMacro(exceptiontype,x) \
{ \
::itk::exceptiontype e_(__FILE__, __LINE__); \
std::ostringstream message; \
message << "itk::ERROR: " x; \
e_.SetDescription(message.str().c_str()); \
e_.SetLocation(ITK_LOCATION); \
throw e_; /* Explicit naming to work around Intel compiler bug. */ \
}
#define itkGenericOutputMacro(x) \
{ \
if ( ::itk::Object::GetGlobalWarningDisplay() ) \
{ \
std::ostringstream itkmsg; \
itkmsg << "WARNING: In " __FILE__ ", line " << __LINE__ << "\n" \
x << "\n\n"; \
::itk::OutputWindowDisplayGenericOutputText( itkmsg.str().c_str() ); \
} \
}
//----------------------------------------------------------------------------
// Macros for simplifying the use of logging
//
#define itkLogMacro(x, y) \
{ \
if ( this->GetLogger() ) \
{ \
this->GetLogger()->Write(::itk::LoggerBase::x, y); \
} \
}
#define itkLogMacroStatic(obj, x, y) \
{ \
if ( obj->GetLogger() ) \
{ \
obj->GetLogger()->Write(::itk::LoggerBase::x, y); \
} \
}
//----------------------------------------------------------------------------
// Setup legacy code policy.
//
// CMake options ITK_LEGACY_REMOVE and ITK_LEGACY_SILENT are converted
// They may be used to completely remove legacy code or silence the
// warnings. The default is to warn about their 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());
#if defined( ITK_LEGACY_REMOVE )
#define itkLegacyMacro(method) /* no ';' */
#elif defined( ITK_LEGACY_SILENT ) || defined( ITK_LEGACY_TEST ) || defined( CSWIG )
// Provide legacy methods with no warnings.
#define itkLegacyMacro(method) method
#else
// Setup compile-time warnings for uses of deprecated methods if
// possible on this compiler.
#if defined( __GNUC__ ) && !defined( __INTEL_COMPILER ) && ( __GNUC__ > 3 || ( __GNUC__ == 3 && __GNUC_MINOR__ >= 1 ) )
#define itkLegacyMacro(method) method __attribute__( ( deprecated ) )
#elif defined( _MSC_VER )
#define itkLegacyMacro(method) __declspec(deprecated) method
#else
#define itkLegacyMacro(method) method
#endif
#endif
// Macros to create runtime deprecation warning messages in function
// bodies. Example usage:
//
// void itkMyClass::MyOldMethod()
// {
// itkLegacyBodyMacro(itkMyClass::MyOldMethod, 2.0);
// }
//
// void itkMyClass::MyMethod()
// {
// itkLegacyReplaceBodyMacro(itkMyClass::MyMethod, 2.0,
// itkMyClass::MyOtherMethod);
// }
#if defined( ITK_LEGACY_REMOVE ) || defined( ITK_LEGACY_SILENT )
#define itkLegacyBodyMacro(method, version)
#define itkLegacyReplaceBodyMacro(method, version, replace)
#define itkGenericLegacyBodyMacro(method, version)
#define itkGenericLegacyReplaceBodyMacro(method, version, replace)
#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
#if defined ( ITK_LEGACY_REMOVE )
#define ITK_TEMPLATE_TXX "error ITK_TEMPLATE_TXX is no longer a supported identifier, you should replace with ITK_MANUAL_INSTANTIATION as a replacement"
#else
#define ITK_TEMPLATE_TXX 1
#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.
#define 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 typedef to make a
// data structure aligned.
//
#if defined ( ITK_HAS_CPP11_ALIGNAS )
# define itkAlignedTypedef( alignment, oldtype, newtype ) \
typedef oldtype newtype alignas(alignment)
#elif defined( ITK_HAS_GNU_ATTRIBUTE_ALIGNED )
# define itkAlignedTypedef( alignment, oldtype, newtype ) \
typedef oldtype newtype __attribute__((aligned(alignment)))
#elif defined ( _MSC_VER )
# define itkAlignedTypedef( alignment, oldtype, newtype ) \
typedef __declspec(align( alignment )) struct oldtype newtype
#else
# define itkAlignedTypedef( alignment, oldtype, newtype ) \
typedef oldtype newtype
#endif
//=============================================================================
/* 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 in some compilers as:
class A
{
public:
friend Self add<Self>( const Self & a, const Self & b );
}
while other compilers will do
class A
{
public:
friend Self add<>( const Self & a, const Self & b );
}
This characteristic of the compiler is checked by a TRY_COMPILE
command defined in Insight/CMake/itkTestFriendTemplatedFunction.cxx
*/
#if defined( ITK_SUPPORTS_TEMPLATED_FRIEND_FUNCTION_WITH_NULL_STRING )
#define ITK_FRIEND_TEMPLATE_FUNCTION_ARGUMENT(T)
#else
#if defined( ITK_SUPPORTS_TEMPLATED_FRIEND_FUNCTION_WITH_EMPTY_BRACKETS )
#define ITK_FRIEND_TEMPLATE_FUNCTION_ARGUMENT(T) < >
#else
#if defined( ITK_SUPPORTS_TEMPLATED_FRIEND_FUNCTION_WITH_TEMPLATE_ARGUMENTS )
#define ITK_FRIEND_TEMPLATE_FUNCTION_ARGUMENT(T) < T >
#endif
#endif
#endif
// THIS IS A TEMPORARY PATCH FOR Visual Studio 10. The correct solution must
// be implemented in Insight/CMake/itkTestFriendTemplatedFunction.cxx
#if ( defined ( _MSC_VER ) && ( _MSC_VER >= 1600 ) )
#ifdef ITK_FRIEND_TEMPLATE_FUNCTION_ARGUMENT
#undef ITK_FRIEND_TEMPLATE_FUNCTION_ARGUMENT
#endif
#define ITK_FRIEND_TEMPLATE_FUNCTION_ARGUMENT(T)
#endif
//=============================================================================
/* Choose a way to prevent template instantiation on this platform.
- ITK_TEMPLATE_DO_NOT_INSTANTIATE = use #pragma do_not_instantiate to
prevent instantiation
- ITK_TEMPLATE_EXTERN = use extern template to prevent instantiation
*/
#if defined( __INTEL_COMPILER ) && __INTEL_COMPILER >= 700
#define ITK_TEMPLATE_EXTERN 1
#elif defined( __GNUC__ ) && __GNUC__ >= 3
#define ITK_TEMPLATE_EXTERN 1
#elif defined( _MSC_VER )
#define ITK_TEMPLATE_EXTERN 1
#endif
#if !defined( ITK_TEMPLATE_DO_NOT_INSTANTIATE )
#define ITK_TEMPLATE_DO_NOT_INSTANTIATE 0
#endif
#if !defined( ITK_TEMPLATE_EXTERN )
#define ITK_TEMPLATE_EXTERN 0
#endif
/* Define a macro to explicitly instantiate a template.
- ITK_TEMPLATE_EXPORT(X) =
Explicitly instantiate X, where X is of the form N(a1[,a2...,aN]).
examples: ITK_TEMPLATE_EXPORT(1(class Foo<int>))
ITK_TEMPLATE_EXPORT(2(class Bar<int, char>))
Use one level of expansion delay to allow user code to have
a macro determining the number of arguments. */
#define ITK_TEMPLATE_EXPORT(x) ITK_TEMPLATE_EXPORT_DELAY(x)
#define ITK_TEMPLATE_EXPORT_DELAY(x) template ITK_TEMPLATE_##x;
/* Define a macro to prevent template instantiations.
- ITK_TEMPLATE_IMPORT(X) =
Prevent instantiation of X, where X is of the form N(a1[,a2...,aN]).
examples: ITK_TEMPLATE_IMPORT(1(class Foo<int>))
ITK_TEMPLATE_IMPORT(2(class Bar<int, char>))
Use one level of expansion delay to allow user code to have
a macro determining the number of arguments.
*/
#if ITK_TEMPLATE_EXTERN
#define ITK_TEMPLATE_IMPORT_DELAY(x) extern template ITK_TEMPLATE_##x;
#elif ITK_TEMPLATE_DO_NOT_INSTANTIATE
#define ITK_TEMPLATE_IMPORT_DELAY(x) \
ITK_TEMPLATE_IMPORT_IMPL(do_not_instantiate ITK_TEMPLATE_##x)
#define ITK_TEMPLATE_IMPORT_IMPL(x) _Pragma(#x)
#endif
#if defined( ITK_TEMPLATE_IMPORT_DELAY )
#define ITK_TEMPLATE_IMPORT(x) ITK_TEMPLATE_IMPORT_DELAY(x)
#define ITK_TEMPLATE_IMPORT_WORKS 1
#else
#define ITK_TEMPLATE_IMPORT(x)
#define ITK_TEMPLATE_IMPORT_WORKS 0
#endif
//=============================================================================
/* Define macros to export and import template instantiations for each
library in ITK. */
#define ITK_EXPORT_ITKCommon(c, x, n) \
ITK_EXPORT_TEMPLATE(ITKCommon_EXPORT, c, x, n)
#define ITK_IMPORT_ITKCommon(c, x, n) \
ITK_IMPORT_TEMPLATE(ITKCommon_EXPORT, c, x, n)
//--------------------------------------------------------------------------------
// 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 perfomed as part of the
// assignment, by using the DestinationElementType as the casting type.
// Source and destination array types must have defined opearator[] 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] ); \
}
//--------------------------------------------------------------------------------
// 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
// perfomed as part of the assignment, by using the DestinationElementType as
// the casting type.
// Source and destination array types must have defined opearator[] 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]); \
}
// end of Template Meta Programming helper macros
#ifndef NDEBUG
#ifdef _POSIX_SOURCE
#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() ); \
}
#ifndef NDEBUG
#define itkAssertInDebugAndIgnoreInReleaseMacro(X) assert(X)
#else
#define itkAssertInDebugAndIgnoreInReleaseMacro(X)
#endif
#ifdef ITKV3_COMPATIBILITY
// As of MSVS++ 7.1 and greater, typename is supported in templates
// All ITKv4 compilers support the typename keyword, but this is
// needed to ease transition from ITKv3.
#define ITK_TYPENAME typename
#endif
/** itkDynamicCastInDebugMode
* Use static_cast in Release builds, and dynamic_cast in Debug
*/
template <typename TTarget, typename TSource>
TTarget itkDynamicCastInDebugMode(TSource x)
{
#ifndef NDEBUG
if(x == 0)
{
return 0;
}
TTarget rval = dynamic_cast<TTarget>(x);
if(rval == 0)
{
itkGenericExceptionMacro(<< "Failed dynamic cast to "
<< typeid(TTarget).name()
<< " object type = "
<< x->GetNameOfClass());
}
return rval;
#else
return static_cast<TTarget>(x);
#endif
// !!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!
// !!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!
// !! The ITK Get/Set Macros for various types !!
// !!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!
// !!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!
//This is probably better, but requires a lot of extra work
//for gettting ExplicitInstantiation to work properly. \#define
// itkStaticConstMacro(name, type, value) static const type name = value
#define itkStaticConstMacro(name, type, value) enum { name = value }
#define itkGetStaticConstMacro(name) (Self::name)
/** Set an input. This defines the Set"name"() method */
#define itkSetInputMacro(name, type) \
virtual void Set##name(const type *_arg) \
{ \
itkDebugMacro("setting input " #name " to " << _arg); \
if ( _arg != static_cast< type * >( this->ProcessObject::GetInput(#name) ) ) \
{ \
this->ProcessObject::SetInput( #name, const_cast< type * >( _arg ) ); \
this->Modified(); \
} \
}
/** Get an input. This defines the Get"name"() method */
#define itkGetInputMacro(name, type) \
virtual const type * Get##name() const \
{ \
itkDebugMacro( "returning input " << #name " of " \
<< static_cast< const type * >( this->ProcessObject::GetInput(#name) ) ); \
return static_cast< const type * >( this->ProcessObject::GetInput(#name) ); \
}
/** Set a decorated input. This defines the Set"name"() and a Set"name"Input() method */
#define itkSetDecoratedInputMacro(name, type) \
virtual void Set##name##Input(const SimpleDataObjectDecorator< type > *_arg) \
{ \
itkDebugMacro("setting input " #name " to " << _arg); \
if ( _arg != static_cast< SimpleDataObjectDecorator< type > * >( this->ProcessObject::GetInput(#name) ) ) \
{ \
this->ProcessObject::SetInput( #name, const_cast< SimpleDataObjectDecorator< type > * >( _arg ) ); \
this->Modified(); \
} \
} \
virtual void Set##name(const type &_arg) \
{ \
typedef SimpleDataObjectDecorator< type > DecoratorType; \
itkDebugMacro("setting input " #name " to " << _arg); \
const DecoratorType *oldInput = \
static_cast< const DecoratorType * >( \
this->ProcessObject::GetInput(#name) ); \
if ( oldInput && oldInput->Get() == _arg ) \
{ \
return; \
} \
typename DecoratorType::Pointer newInput = DecoratorType::New(); \
newInput->Set(_arg); \
this->Set##name##Input(newInput); \
}
/** Set a decorated input. This defines the Set"name"() and Set"name"Input() method */
#define itkGetDecoratedInputMacro(name, type) \
virtual const SimpleDataObjectDecorator< type > * Get##name##Input() const \
{ \
itkDebugMacro( "returning input " << #name " of " \
<< static_cast< const SimpleDataObjectDecorator< type > * >( this->ProcessObject::GetInput(#name) ) ); \
return static_cast< const SimpleDataObjectDecorator< type > * >( this->ProcessObject::GetInput(#name) ); \
} \
virtual const type & Get##name() const \
{ \
itkDebugMacro("Getting input " #name); \
typedef SimpleDataObjectDecorator< type > DecoratorType; \
const DecoratorType *input = \
static_cast< const DecoratorType * >( \
this->ProcessObject::GetInput(#name) ); \
if( input == NULL ) \
{ \
itkExceptionMacro(<<"input" #name " is not set"); \
} \
return input->Get(); \
}
/** Set a decorated input. This defines the Set"name"() and Set"name"Input() method
* and Get"name" and Get"name"Input methods */
#define itkSetGetDecoratedInputMacro(name, type) \
itkSetDecoratedInputMacro(name, type) \
itkGetDecoratedInputMacro(name, type)
/** Set a decorated input that derives from itk::Object, but not from
* itk::DataObject. This defines the Set"name"() and Set"name"Input
* methods.
*/
#define itkSetDecoratedObjectInputMacro(name, type) \
virtual void Set##name##Input(const DataObjectDecorator< type > *_arg) \
{ \
itkDebugMacro("setting input " #name " to " << _arg); \
if ( _arg != static_cast< DataObjectDecorator< type > * >( this->ProcessObject::GetInput(#name) ) ) \
{ \
this->ProcessObject::SetInput( #name, const_cast< DataObjectDecorator< type > * >( _arg ) ); \
this->Modified(); \
} \
} \
virtual void Set##name(const type * _arg) \
{ \
typedef DataObjectDecorator< type > DecoratorType; \
itkDebugMacro("setting input " #name " to " << _arg); \
const DecoratorType *oldInput = \
static_cast< const DecoratorType * >( \
this->ProcessObject::GetInput(#name) ); \
if ( oldInput && oldInput->Get() == _arg ) \
{ \
return; \
} \
typename DecoratorType::Pointer newInput = DecoratorType::New(); \
newInput->Set(_arg); \
this->Set##name##Input(newInput); \
}
/** Get a decorated input that derives from itk::Object, but not from
* itk::DataObject. This defines the Get"name"() and Get"name"Input
* methods.
*/
#define itkGetDecoratedObjectInputMacro(name, type) \
virtual const DataObjectDecorator< type > * Get##name##Input() const \
{ \
itkDebugMacro( "returning input " << #name " of " \
<< static_cast< const DataObjectDecorator< type > * >( this->ProcessObject::GetInput(#name) ) ); \
return static_cast< const DataObjectDecorator< type > * >( this->ProcessObject::GetInput(#name) ); \
} \
virtual const type * Get##name() const \
{ \
itkDebugMacro("Getting input " #name); \
typedef DataObjectDecorator< type > DecoratorType; \
const DecoratorType *input = \
static_cast< const DecoratorType * >( \
this->ProcessObject::GetInput(#name) ); \
if( input == NULL ) \
{ \
itkExceptionMacro(<<"input" #name " is not set"); \
} \
return input->Get(); \
}
/** Set a decorated input. This defines the Set"name"() and Set"name"Input() method
* and Get"name" and Get"name"Input methods */
#define itkSetGetDecoratedObjectInputMacro(name, type) \
itkSetDecoratedObjectInputMacro(name, type) \
itkGetDecoratedObjectInputMacro(name, type)
/** Set built-in type. Creates member Set"name"() (e.g., SetVisibility()); */
#define itkSetMacro(name, type) \
virtual void Set##name (const type _arg) \
{ \
itkDebugMacro("setting " #name " to " << _arg); \
if ( this->m_##name != _arg ) \
{ \
this->m_##name = _arg; \
this->Modified(); \
} \
}
/** Get built-in type. Creates member Get"name"() (e.g., GetVisibility()); */
#define itkGetMacro(name, type) \
virtual type Get##name () \
{ \
return this->m_##name; \
}
/** Get built-in type. Creates member Get"name"() (e.g., GetVisibility());
* This is the "const" form of the itkGetMacro. It should be used unless
* the member can be changed through the "Get" access routine. */
#define itkGetConstMacro(name, type) \
virtual type Get##name () const \
{ \
return this->m_##name; \
}
/** Get built-in type. Creates member Get"name"() (e.g., GetVisibility());
* This is the "const" form of the itkGetMacro. It should be used unless
* the member can be changed through the "Get" access routine.
* This versions returns a const reference to the variable. */
#define itkGetConstReferenceMacro(name, type) \
virtual const type &Get##name () const \
{ \
return this->m_##name; \
}
/** Set built-in type. Creates member Set"name"() (e.g., SetVisibility());
* This should be use when the type is an enum. It is use to avoid warnings on
* some compilers with non specified enum types passed to
* itkDebugMacro. */
#define itkSetEnumMacro(name, type) \
virtual void Set##name (const type _arg) \
{ \
itkDebugMacro( "setting " #name " to " << static_cast< long >( _arg ) ); \
if ( this->m_##name != _arg ) \
{ \
this->m_##name = _arg; \
this->Modified(); \
} \
}
/** Get built-in type. Creates member Get"name"() (e.g., GetVisibility());
* This should be use when the type is an enum. It is use to avoid warnings on
* some compilers with non specified enum types passed to
* itkDebugMacro. */
#define itkGetEnumMacro(name, type) \
virtual type Get##name () const \
{ \
return this->m_##name; \
}
/** Set character string. Creates member Set"name"()
* (e.g., SetFilename(char *)). The macro assumes that
* the class member (name) is declared a type std::string. */
#define itkSetStringMacro(name) \
virtual void Set##name (const char *_arg) \
{ \
if ( _arg && ( _arg == this->m_##name ) ) { return; } \
if ( _arg ) \
{ \
this->m_##name = _arg; \
} \
else \
{ \
this->m_##name = ""; \
} \
this->Modified(); \
} \
virtual void Set##name (const std::string & _arg) \
{ \
this->Set##name( _arg.c_str() ); \
} \
/** Get character string. Creates member Get"name"()
* (e.g., SetFilename(char *)). The macro assumes that
* the class member (name) is declared as a type std::string. */
#define itkGetStringMacro(name) \
virtual const char *Get##name () const \
{ \
return this->m_##name.c_str(); \
}
/** Set built-in type where value is constrained between min/max limits.
* Create member Set"name"() (e.q., SetRadius()). \#defines are
* convienience for clamping open-ended values. */
#define itkSetClampMacro(name, type, min, max) \
virtual void Set##name (type _arg) \
{ \
itkDebugMacro("setting " << #name " to " << _arg); \
if ( this->m_##name != ( _arg < min ? min : ( _arg > max ? max : _arg ) ) ) \
{ \
this->m_##name = ( _arg < min ? min : ( _arg > max ? max : _arg ) ); \
this->Modified(); \
} \
}
/** Set pointer to object; uses Object reference counting methodology.
* Creates method Set"name"() (e.g., SetPoints()). Note that using
* smart pointers requires using real pointers when setting input,
* but returning smart pointers on output. */
#define itkSetObjectMacro(name, type) \
virtual void Set##name (type * _arg) \
{ \
itkDebugMacro("setting " << #name " to " << _arg); \
if ( this->m_##name != _arg ) \
{ \
this->m_##name = _arg; \
this->Modified(); \
} \
}
/** Get a smart pointer to an object. Creates the member
* Get"name"() (e.g., GetPoints()).
* NOTE: This function returns a non-const
* version of the internal member variable
* and could easily be used to modify the
* behavior of the class without
* properly resetting the pipeline
* symantics */
// 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 permissable to use both itkGetObjectMacro and itkGetConstObjectMacro
// for backwards compatibility.
// If the ITK_LEGACY_REMOVE=FALSE, then it is
// permissable to use itkGetObjectMacro which
// defines both signatures itk::GetXXX() and
// itk::GetModifiableXXX()
/** Get a smart const pointer to an object. Creates the member
* Get"name"() (e.g., GetPoints()). */
#define itkGetConstObjectMacro(name, type) \
virtual const type * Get##name () const \
{ \
return this->m_##name.GetPointer(); \
}
#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
# define itkGetObjectMacro(name, type) \
virtual type * Get##name () \
{ \
purposeful_error("itkGetObjectMacro should be replaced with itkGetModifiableObjectMacro."); \
}
# define itkGetModifiableObjectMacro(name, type) \
virtual type * GetModifiable##name () \
{ \
return this->m_##name.GetPointer(); \
} \
itkGetConstObjectMacro(name, type)
#else // defined ( ITK_FUTURE_LEGACY_REMOVE )
/** Get a smart pointer to an object. Creates the member
* Get"name"() (e.g., GetPoints()). */
# define itkGetObjectMacro(name, type) \
virtual type * Get##name () \
{ \
return this->m_##name.GetPointer(); \
}
# define itkGetModifiableObjectMacro(name, type) \
virtual type * GetModifiable##name () \
{ \
return this->m_##name.GetPointer(); \
} \
itkGetConstObjectMacro(name, type) \
itkGetObjectMacro(name, type)
#endif // defined ( ITK_FUTURE_LEGACY_REMOVE )
// For backwards compatibility define ITK_EXPORT to nothing
#define ITK_EXPORT
/** Get a const reference to a smart pointer to an object.
* Creates the member Get"name"() (e.g., GetPoints()). */
#define itkGetConstReferenceObjectMacro(name, type) \
virtual const typename type::Pointer & Get##name () const \
{ \
return this->m_##name; \
}
/** Set const pointer to object; uses Object reference counting methodology.
* Creates method Set"name"() (e.g., SetPoints()). Note that using
* smart pointers requires using real pointers when setting input,
* but returning smart pointers on output. */
#define itkSetConstObjectMacro(name, type) \
virtual void Set##name (const type * _arg) \
{ \
itkDebugMacro("setting " << #name " to " << _arg); \
if ( this->m_##name != _arg ) \
{ \
this->m_##name = _arg; \
this->Modified(); \
} \
}
/** Create members "name"On() and "name"Off() (e.g., DebugOn() DebugOff()).
* Set method must be defined to use this macro. */
#define itkBooleanMacro(name) \
virtual void name##On () \
{ \
this->Set##name(true); \
} \
virtual void name##Off () \
{ \
this->Set##name(false); \
}
/** General set vector macro creates a single method that copies specified
* number of values into object.
* Examples: void SetColor(c,3) */
#define itkSetVectorMacro(name, type, count) \
virtual void Set##name(type data[]) \
{ \
unsigned int i; \
for ( i = 0; i < count; i++ ) \
{ \
if ( data[i] != this->m_##name[i] ) \
{ \
break; \
} \
} \
if ( i < count ) \
{ \
this->Modified(); \
for ( i = 0; i < count; i++ ) \
{ \
this->m_##name[i] = data[i]; \
} \
} \
}
/** Get vector macro. Returns pointer to type (i.e., array of type).
* This is for efficiency. */
#define itkGetVectorMacro(name, type, count) \
virtual type * Get##name () const \
{ \
return this->m_##name; \
}
/** Construct a non-templatized helper class that
* provides the GPU kernel source code as a const char*
*/
#define itkGPUKernelClassMacro(kernel) \
class kernel \
{ \
public: \
static const char* GetOpenCLSource(); \
private: \
kernel(); \
virtual ~kernel(); \
kernel(const kernel &); \
void operator=(const kernel &); \
};
#define itkGetOpenCLSourceFromKernelMacro(kernel) \
static const char* GetOpenCLSource() \
{ \
return kernel::GetOpenCLSource(); \
}
}
#endif //end of itkMacro.h
|