就业培训     下载中心     Wiki     联络 登录   注册
  1. 首页
  2. C4D R23.110 C++ SDK
Classes | Namespaces | Macros | Typedefs | Enumerations | 函数 | 变量

apibase.h File Reference

详细描述

Main include file

Classes

struct   IntType< BYTES >
struct   IntType< 1 >
struct   IntType< 2 >
struct   IntType< 4 >
struct   IntType< 8 >
struct   UIntType< BYTES >
struct   UIntType< 1 >
struct   UIntType< 2 >
struct   UIntType< 4 >
struct   UIntType< 8 >
struct   StandardType< T, INTEGRAL >
struct   StandardType< T, true >
class   Block< T, STRIDED, MOVE >
class   Result< RESULT_TYPE >
class   ResultOk< T >
class   EmptyClass
class   EmptyVirtualClass
class   SFINAEHelper< T, CHECK >
struct   is_constructible< maxon::Generic, const maxon::Generic & >
class   PrivateOverloadRank0
class   PrivateOverloadRank1
class   PrivateOverloadRank2
class   PrivateOverloadRank3
class   PrivateOverloadRank4
class   PrivateOverloadRank5
struct   AlwaysFalse< T >
struct   And<... >
struct   And< true, REST... >
struct   And< false, REST... >
struct   And<>
class   Protected< SUPER >
class   ConstIf< T, MAKECONST >
class   ConstIf< T, true >
class   InheritConst< T, INHERIT_FROM >
class   InheritConst< T, const INHERIT_FROM >
class   Substitute< T, R >
class   Substitute< T &, R >
class   Substitute< T &&, R >
struct   ParameterPack< T >
struct   ParameterPackContainsAll< PACK, X >
struct   ParameterPackContainsAll< PACK, ParameterPack< X... > >
struct   ParameterPack< T >
struct   ParameterPack< T >::IndexOf< X >
struct   ParameterPack< T >::At< INDEX >
struct   ParameterPack< T, REST... >
struct   ParameterPack< T, REST... >::IndexOf< X >
struct   GetSignature< FUNCTION >
struct   GetSignature< RET(ARGS...)>
struct   GetSignature< RET(*)(ARGS...)>
class   CommonLValue< T, A, B >
class   CommonType< A, B >
struct   MemberDetectorHelper< U, U >
class   EnableIfFlag< T, FLAGS, A, B >
class   IsCompleteBase< T, Int, value >
class   IsComplete< T, COUNTER >
struct   GetReferencedType< T, DEF, typename >
struct   GetReferencedType< T, DEF, typename maxon::SFINAEHelper< void, typename std::decay< T >::type::ReferencedType >::type >
struct   GetConstReferencedType< T, DEF, typename >
struct   GetConstReferencedType< T, DEF, typename maxon::SFINAEHelper< void, typename std::decay< T >::type::ConstReferencedType >::type >
struct   GetDirectlyReferencedType< T, DEF, typename >
struct   GetDirectlyReferencedType< T, DEF, typename maxon::SFINAEHelper< void, typename std::decay< T >::type::DirectlyReferencedType >::type >
struct   GetErasedType< T, DEF, typename >
struct   GetErasedType< T, DEF, typename maxon::SFINAEHelper< void, typename std::decay< T >::type::ErasedType >::type >
struct   GetDirectlyReferencedTypeCheckConstAndPtr< REF >
struct   IsAllocType< T, DEF, typename >
struct   IsAllocType< T, DEF, typename maxon::SFINAEHelper< void, typename std::decay< T >::type::IsAllocType >::type >
struct   IsNonvirtualInterfaceType< T, DEF, typename >
struct   IsNonvirtualInterfaceType< T, DEF, typename maxon::SFINAEHelper< void, typename std::decay< T >::type::NonvirtualInterfaceMarker >::type >
struct   IsVirtualInterfaceType< T, DEF, typename >
struct   IsVirtualInterfaceType< T, DEF, typename maxon::SFINAEHelper< void, typename std::decay< T >::type::InterfaceMarker >::type >
struct   IsInterfaceType< T, DEF, typename >
struct   IsInterfaceType< T, DEF, typename maxon::SFINAEHelper< void, typename std::decay< T >::type::MTable >::type >
struct   GetValueType< T, DEF, typename >
struct   GetValueType< T, DEF, typename maxon::SFINAEHelper< void, typename std::decay< T >::type::ValueType >::type >
struct   CheckHasBase< T, DEF, typename >
struct   CheckHasBase< T, DEF, typename maxon::SFINAEHelper< void, typename std::decay< T >::type::HasBase >::type >
struct   GetNonConst< T, DEF, typename >
struct   GetNonConst< T, DEF, typename maxon::SFINAEHelper< void, typename std::decay< T >::type::NonConst >::type >
struct   GetHandler< T, DEF, typename >
struct   GetHandler< T, DEF, typename maxon::SFINAEHelper< void, typename std::decay< T >::type::Handler >::type >
class   IsReferenceClass< T >
class   IsObjectReferenceClass< T >
struct   IsPartiallyOrdered< T, DEF, typename >
struct   IsPartiallyOrdered< T, DEF, typename maxon::SFINAEHelper< void, typename std::decay< T >::type::PartiallyOrdered >::type >
struct   IsTriviallyEquatable< T >
struct   IsZeroInitialized< T >
struct   IsZeroInitialized< Generic >
class   UnitType
class   GenericArithmetic
class   HasBaseHelper< D, B, HAS_BASE_OR_SAME >
class   HasBaseHelper< D, B, 1 >
class   HasBaseHelper< D, B, 2 >
struct   HasBaseHelper< Generic, InternedId, 0 >
struct   DefaultHasBase< D >
struct   DefaultHasBase< D >::Check< I >
struct   MakeLValueConst< T >
struct   MakeLValueConst< T & >
struct   CheckHasBaseHelper< DT, BT >
struct   CheckHasBaseHelper< T, T >
struct   HasBase< D, B >
struct   IsDerived< BASE >
struct   IsDerived< BASE >::Check< DERIVED >
struct   HasErasedBase< D, B >
struct   GenericCastMemberTrait< TO, FROM, SAFE, typename >
struct   GenericCastMemberTrait< const TO &, FROM, SAFE >
struct   GenericCastMemberTrait< const TO &, FROM &, SAFE >
struct   GenericCastMemberTrait< TO &, FROM &, SAFE >
struct   GenericCastMemberTrait< const TO *, FROM *, SAFE >
struct   GenericCastMemberTrait< TO *, FROM *, SAFE >
struct   GenericCastTrait< TO, FROM, SAFE, typename >
class   ByValueParam< T >
class   MultiplicativePromotion< T1, T2, Bool >
class   MultiplicativePromotion< T1, T2, false >
class   MultiplicativePromotion< GenericArithmetic, T, true >
class   MultiplicativePromotion< T, GenericArithmetic, true >
class   MultiplicativePromotion< GenericArithmetic, GenericArithmetic, true >
class   Dereference< T, ALSO_REFS >
class   BaseRef< T, HANDLER >
class   Dereference< BaseRef< T, HANDLER >, false >
struct   HashValue
class   Result< RESULT_TYPE >
class   ResultOk< T >
class   ThreadReferencedError
struct   ValueKindHelper< T, REF >
struct   ValueKindHelper< T *, REF >
struct   ValueKindHelper< T, true >
struct   ValueKindHelper< ObjectInterface, false >
class   GetCollectionKind< COLLECTION, ENABLE >
struct   TestForCopyFromMember< T >
class   ObjectConstructor< T, hasCopyFrom >
class   ObjectConstructor< T, false >
struct   AlignedStorage< SIZE, ALIGN >
class   BoolLValue

Namespaces

  maxon
  std
  std::maxon_std
  maxon::details

Macros

#define  MAXON_API_ABI_VERSION
#define  DOXYGEN_SWITCH (CPP, DOX)
#define  MAXON_DEPENDENCY_ENABLE
#define  MAXON_DEPENDENCY_ENABLEtrue
#define  MAXON_PREPROCESSOR_CONDITION (X)
#define  MAXON_ATTRIBUTE_DLL_PUBLIC
#define  MAXON_ATTRIBUTE_NO_INLINE
#define  MAXON_ATTRIBUTE_FORCE_INLINE
#define  MAXON_ATTRIBUTE_USED
#define  PRIVATE_MAXON_DEPRECATED_ENUMVALUE (name, value, reason)
#define  MAXON_DEPRECATED_ENUMVALUE (name, value, reason)
#define  MAXON_IMPLICIT
#define  MAXON_ATTRIBUTE_SYSCHAR_IS_CHAR
#define  MAXON_CONSTEXPR_EVAL (T, X)
#define  PRIVATE_MAXON_AS_UTF8 (x)
#define  CONSTSTRING (x)
#define  MAXON_CACHE_LINE_SIZE
#define  MAXON_FALSE_SHARING_SIZE
#define  MAXON_HAS_TRUE_TYPE (E)
#define  OVERLOAD_MAX_RANK
#define  MAXON_MEMBERFUNCTION_DETECTOR (Name)
#define  MAXON_MEMBERTYPE_DETECTOR (Name, Member, Default)
#define  PRIVATE_MAXON_DEFAULT_REFERENCE_CONSTRUCTORS (Cls, ...)
#define  MAXON_DEFAULT_REFERENCE_CONSTRUCTORS (Cls, ...)
#define  MAXON_UNIQUE_REFERENCE_CONSTRUCTORS (Cls, ...)
#define  PRIVATE_MAXON_TRANSLATIONUNIT_FLAGS
#define  PRIVATE_MAXON_TRANSLATIONUNIT_FLAGS_2
#define  PRIVATE_MAXON_DETECT_MEMBER_HELPER1 (x, i, a)
#define  PRIVATE_MAXON_DETECT_MEMBER_HELPER2 (x, i, a)
#define  PRIVATE_MAXON_DETECT_MEMBER_HELPER3 (x, i, a)
#define  MAXON_DETECT_MEMBER_HELPER (NAME, ...)
#define  MAXON_IS_COW_KIND (kind)
#define  MAXON_SCOPE
#define  MAXON_WARN_MUTE_FUNCTION_LENGTH
#define  MAXON_WARN_MUTE_NAMING
#define  MAXON_TARGET_UNITY_MODE
#define  PRIVATE_MAXON_REGISTER_CHECK (NAME)

Typedefs

using  Int16 = int16_t
using  UInt16 = uint16_t
using  Int32 = int32_t
using  UInt32 = uint32_t
using  Int64 = int64_t
using  UInt64 = uint64_t
using  Bool = bool
using  Float32 = float
using  Float64 = double
using  Char = char
using  UChar = unsigned char
using  Int = Int64
using  UInt = UInt64
using  Float = Float64
using  Utf32Char = char32_t
using  Utf16Char = char16_t
using  SysChar = char
using  HashInt = UInt
using  OverloadRank0 = PrivateOverloadRank0 *
using  OverloadRank1 = PrivateOverloadRank1 *
using  OverloadRank2 = PrivateOverloadRank2 *
using  OverloadRank3 = PrivateOverloadRank3 *
using  OverloadRank4 = PrivateOverloadRank4 *
using  OverloadRank5 = PrivateOverloadRank5 *
using  OverloadRankMax = OverloadRank5
template<typename T , Int N>
using  AddArrayT = T[N]
template<typename T >
using  AddArrayOfUnknownBoundT = T[]
template<typename TO , typename FROM , Bool SAFE>
using  GenericCastReturnType = std::enable_if< GenericCastTrait< TO , typename maxon::details::MakeLValueConst < FROM >::type, SAFE >::value, typename GenericCastTrait< TO , typename maxon::details::MakeLValueConst < FROM >::type, SAFE >::ReturnType >
using  InitMTable = void(*)()

Enumerations

enum   ENUM_DONT_INITIALIZE { VALUE }
enum   IN_PLACE_TYPE { VALUE }
enum   VALUEKIND : UInt64 {
   NONE ,
   VOID_TYPE ,
   GENERIC ,
   GENERIC_ARITHMETIC ,
   SCALAR ,
   INTEGRAL ,
   FLOATING_POINT ,
   ENUM ,
   DATA ,
   DATAPTR ,
   NONVIRTUAL_INTERFACE ,
   VIRTUAL_INTERFACE ,
   REF_OR_POINTER ,
   POINTER ,
   STRONG_REFERENCE ,
   COW_REFERENCE ,
   UNIQUE_REFERENCE ,
   ACOW_REFERENCE ,
   LV_REFERENCE ,
   RV_REFERENCE ,
   TUPLE ,
   STRUCT ,
   SIMD ,
   BLOCK ,
   STRIDED_BLOCK ,
   BASEARRAY ,
   BLOCKARRAY ,
   RESULT ,
   DELEGATE ,
   FUNCTION ,
   CONST_QUALIFIED ,
   OPAQUE_QUALIFIED ,
   SOURCE_LEVEL ,
   DEEP_CONSTNESS ,
   INT_SIZE_OR_LESS ,
   ZERO_INITIALIZED ,
   ORDERED ,
   TRIVIALLY_CONSTRUCTIBLE ,
   TRIVIALLY_DESTRUCTIBLE ,
   TRIVIALLY_COPYABLE ,
   TRIVIALLY_EQUATABLE ,
   OBJECT_REF ,
   VALUE ,
   ELEMENT_TYPE_AS_ARG ,
   NEVER_NULLPTR ,
   SIGNED ,
   GENERIC_INSTANTIATION ,
   GLOBALLY_REFERENCED ,
   ABSTRACT ,
   NAMED ,
   CONTAINER_REF ,
   GENERIC_CONTAINER ,
   RECURSIVE_CONTAINER ,
   RESOLVED_RECURSIVE_CONTAINER ,
   CONTAINER ,
   EMPTY_CONTAINER ,
   SINGLETON_CONTAINER ,
   STATIC_ARRAY_CONTAINER ,
   ARRAY_CONTAINER ,
   ARRAY ,
   CONTAINER_MASK ,
   NAMED_TUPLE ,
   CONTAINS_RECURSIVE_CONTAINER ,
   MIN_DERIVED_CONTAINER ,
   MIN_ARRAY_CONTAINER ,
   MAX_ARRAY_CONTAINER ,
   COW_MASK ,
   STRONG_MASK ,
   PTR_MASK ,
   CONTAINER_OR_REF ,
   REFERENCE_MASK ,
   ARITHMETIC_MASK ,
   TUPLE_MASK ,
   TUPLE_INHERIT_MASK ,
   POINTER_FLAGS ,
   QUALIFIER_MASK
}
enum   COLLECTION_KIND {
   NONE ,
   ARRAY ,
   SET ,
   MAP
}

函数

  __attribute__ ((always_inline)) typename std
const String &  StringInterface_GetAndCacheConstString (const wchar_t *str, Int len)
const String &  StringInterface_GetAndCacheConstString (const Char *str, Int len, Int isUtf8)
constexpr Bool   PrivateIsUtf8 (const char *str, Int len)
const String &  operator""_s (const char *str, std::size_t cnt)
const String &  operator""_s (const wchar_t *str, std::size_t cnt)
template<typename T >
String   GlobalToString (const T &object, const FormatStatement *formatStatement, Bool checkDataType=true)
template<typename T , typename E >
E &&  MakeDependentExpr (E &&value)
template<typename T >
T *  addressof (T &x)
enum maxon::ENUM_DONT_INITIALIZE   MAXON_ENUM_LIST (ENUM_DONT_INITIALIZE)
enum maxon::IN_PLACE_TYPE   MAXON_ENUM_LIST (IN_PLACE_TYPE)
template<typename T >
std::enable_if<(sizeof(T) > 0), std::true_type >::type  IsCompleteHelper (T *)
std::false_type  IsCompleteHelper (...)
template<typename T >
const T &  GetZeroRef ()
template<typename T >
const T &  GetPtrSizedZeroRef ()
template<typename TO , typename FROM >
GenericCastReturnType< TO , FROM, false >::type  GenericReinterpretCast (FROM &&value)
template<typename TO , typename FROM >
GenericCastReturnType< TO , FROM, true >::type  GenericUpCast (FROM &&value)
template<typename T >
T  NullValue ()
Bool   MaxonStart (int argc, SysChar **argv, InitMTable initSystemTable, Binary *optionalDependency=nullptr)
Bool   MaxonEnd ()
  Helper (OverloadRank2, T &obj MAXON_MAKE_LIST( PRIVATE_MAXON_DETECT_MEMBER_HELPER1 ,,,,)) -> decltype(obj. GetMemorySize(MAXON_MAKE_COMMA_LIST( PRIVATE_MAXON_DETECT_MEMBER_HELPER2 ,,,)))
template<typename T >
MAXON_ATTRIBUTE_FORCE_INLINE auto  MAXON_CONCAT (GetMemorySize, Helper)(OverloadRank1
MAXON_ATTRIBUTE_FORCE_INLINE auto T &obj  MAXON_MAKE_LIST ( PRIVATE_MAXON_DETECT_MEMBER_HELPER1 ,,,,)) -> decltype(GetMemorySize(obj MAXON_MAKE_LIST( PRIVATE_MAXON_DETECT_MEMBER_HELPER3 ,,,,)))
template<typename T >
MAXON_ATTRIBUTE_FORCE_INLINE auto  MAXON_CONCAT (GetMemorySize, Helper)(T &obj MAXON_MAKE_LIST( PRIVATE_MAXON_DETECT_MEMBER_HELPER1
template<typename X >
MAXON_ATTRIBUTE_FORCE_INLINE autodecltype(MAXON_CONCAT(GetMemorySize, Helper)((( maxon::OverloadRankMax ) nullptr), obj MAXON_MAKE_LIST( PRIVATE_MAXON_DETECT_MEMBER_HELPER3 ,,,,))) T &  __attribute__ ((always_inline)) void UseVariable(X &&var)
enum maxon::VALUEKIND UInt64   MAXON_ENUM_ORDERED_FLAGS (VALUEKIND, "net.maxon.datatype.enum.valuekind", EARLY)
enum maxon::COLLECTION_KIND   MAXON_ENUM_LIST (COLLECTION_KIND)
template<typename T >
std::false_type  TestForCopyFromFunction (OverloadRank0)
template<typename T >
  __attribute__ ((always_inline)) Result< void > NewCopy(T &dst
template<typename T >
  __attribute__ ((always_inline)) ResultOk< T > NewCopy(T &&src)
template<typename T , typename U >
  __attribute__ ((always_inline)) Result< void > AssignCopyConvert(T &dst
template<typename T >
void  Destruct (T *object)
template<typename T >
void  重置 (T &object)
constexpr maxon::Float   operator""_f (long double f)

变量

enum  Byte
static const Int   InvalidArrayIndex
static const Int   MAXON_FLEXIBLE_ARRAY_LENGTH
  VALUE
static const ENUM_DONT_INITIALIZE  DONT_INITIALIZE
static const IN_PLACE_TYPE  IN_PLACE
Int   alignment
const void *  g_zeroMemory
static const void *const  g_zeroPtr
  NONE
  VOID_TYPE
  GENERIC
  GENERIC_ARITHMETIC
  SCALAR
  INTEGRAL
  FLOATING_POINT
  ENUM
  DATA
  DATAPTR
  NONVIRTUAL_INTERFACE
  VIRTUAL_INTERFACE
  REF_OR_POINTER
  POINTER
  STRONG_REFERENCE
  COW_REFERENCE
  UNIQUE_REFERENCE
  ACOW_REFERENCE
  LV_REFERENCE
  RV_REFERENCE
  TUPLE
  STRUCT
  SIMD
  BLOCK
  STRIDED_BLOCK
  BASEARRAY
  BLOCKARRAY
  RESULT
  DELEGATE
  FUNCTION
  CONST_QUALIFIED
  OPAQUE_QUALIFIED
  SOURCE_LEVEL
  DEEP_CONSTNESS
  INT_SIZE_OR_LESS
  ZERO_INITIALIZED
  ORDERED
  TRIVIALLY_CONSTRUCTIBLE
  TRIVIALLY_DESTRUCTIBLE
  TRIVIALLY_COPYABLE
  TRIVIALLY_EQUATABLE
  OBJECT_REF
  ELEMENT_TYPE_AS_ARG
  NEVER_NULLPTR
  SIGNED
  GENERIC_INSTANTIATION
  GLOBALLY_REFERENCED
  ABSTRACT
  NAMED
  CONTAINER_REF
  GENERIC_CONTAINER
  RECURSIVE_CONTAINER
  RESOLVED_RECURSIVE_CONTAINER
  CONTAINER
  EMPTY_CONTAINER
  SINGLETON_CONTAINER
  STATIC_ARRAY_CONTAINER
  ARRAY_CONTAINER
  ARRAY
  CONTAINER_MASK
  NAMED_TUPLE
  CONTAINS_RECURSIVE_CONTAINER
  MIN_DERIVED_CONTAINER
  MIN_ARRAY_CONTAINER
  MAX_ARRAY_CONTAINER
  COW_MASK
  STRONG_MASK
  PTR_MASK
  CONTAINER_OR_REF
  REFERENCE_MASK
  ARITHMETIC_MASK
  TUPLE_MASK
  TUPLE_INHERIT_MASK
  POINTER_FLAGS
  QUALIFIER_MASK
struct maxon::ValueKindHelper   MAXON_ENUM_ORDERED_FLAGS
  SET
  MAP
template<typename T >
decltype(std::declval< T >().CopyFrom(std::declval< const T & >()))  TestForCopyFromFunction (OverloadRank1)
const T &  src
return  OK

Macro Definition Documentation

◆  MAXON_API_ABI_VERSION

#define MAXON_API_ABI_VERSION

The ABI version (Application Binary Interface) of the MAXON API. Only modules compiled with the same ABI version are binary-compatible and can be loaded together.

◆  DOXYGEN_SWITCH

#define DOXYGEN_SWITCH (   CPP,
  DOX 
)

◆  MAXON_DEPENDENCY_ENABLE

#define MAXON_DEPENDENCY_ENABLE

If this macro is undefined while including header files, no automatic dependencies will be set up for the entities declared in the included header files. This should be used with caution. If this mechanism is used, a #undef - #define -pair should surround the includes which shall be ignored for the dependency analysis as in

#undef MAXON_DEPENDENCY_ENABLE #include "myheader.h" // there won't be any automatic dependencies of the current source file on the entities declared in myheader.h #define MAXON_DEPENDENCY_ENABLE

This pattern should only be used in cpp files, but not in header files.

◆  MAXON_DEPENDENCY_ENABLEtrue

#define MAXON_DEPENDENCY_ENABLEtrue

◆  MAXON_PREPROCESSOR_CONDITION

#define MAXON_PREPROCESSOR_CONDITION (   X )

使用 MAXON_PREPROCESSOR_CONDITION(X) in a header file to tell the source processor that the corresponding includes in register.cpp shall be enclosed by #if X ... #endif. You have to use this for system specific header files. Example:

MAXON_PREPROCESSOR_CONDITION (defined(MAXON_TARGET_IOS) || defined(MAXON_TARGET_MACOS));

◆  MAXON_IS_COW_KIND

#define MAXON_IS_COW_KIND (   kind )

◆  MAXON_TARGET_UNITY_MODE

#define MAXON_TARGET_UNITY_MODE

◆  PRIVATE_MAXON_REGISTER_CHECK

#define PRIVATE_MAXON_REGISTER_CHECK (   NAME )

Function Documentation

◆  operator""_f()

constexpr maxon::Float operator""_f ( long double  f )
constexpr

Variable Documentation

◆  VALUE

VALUE

This flag is set if the type is a value type (such as a scalar, a COW reference or a tuple or array of value types).

◆  NONE

NONE

Not a collection.

◆  VOID_TYPE

VOID_TYPE

The data type represents the void type.

◆  GENERIC

GENERIC

The data type represents the Generic type.

◆  GENERIC_ARITHMETIC

GENERIC_ARITHMETIC

The data type is the abstract base type of all arithmetic types.

◆  SCALAR

SCALAR

The type is a scalar type.

◆  INTEGRAL

INTEGRAL

The type is an integral type (that doesn't include enumeration types).

◆  FLOATING_POINT

FLOATING_POINT

The type is a floating point type.

◆  ENUM

ENUM

The data type is an unnamed enum type created by DataTypeLib::GetEnumType().

◆  DATA

DATA

The data type is Data.

◆  DATAPTR

DATAPTR

The data type is one of ConstDataPtr, DataPtr, MoveDataPtr or ForwardingDataPtr.

◆  NONVIRTUAL_INTERFACE

NONVIRTUAL_INTERFACE

The data type is a non-virtual interface.

◆  VIRTUAL_INTERFACE

VIRTUAL_INTERFACE

The data type consists of a set of virtual interfaces.

◆  REF_OR_POINTER

REF_OR_POINTER

This flag is set for a BaseRef-like reference or a pointer.

◆  POINTER

POINTER

The data type is an ordinary C++ pointer, or a BaseRef with raw pointer semantics, or a C++ reference (then one of LV_REFERENCE or RV_REFERENCE is also set).

◆  STRONG_REFERENCE

STRONG_REFERENCE

The data type is a BaseRef with non-copy-on-write reference-counting semantics.

◆  COW_REFERENCE

COW_REFERENCE

The data type is a BaseRef with copy-on-write semantics.

◆  UNIQUE_REFERENCE

UNIQUE_REFERENCE

The data type is a BaseRef with unique ownership, i.e., the referenced object will be freed on destruction of the BaseRef.

◆  ACOW_REFERENCE

ACOW_REFERENCE

The data type is a BaseRef with always-copy-on-write semantics.

◆  LV_REFERENCE

LV_REFERENCE

The type is an l-value reference type. This flag can only be set in conjunction with POINTER, i.e., C++ references are treated as special pointers.

◆  RV_REFERENCE

RV_REFERENCE

The type is an r-value reference type. This flag can only be set in conjunction with POINTER, i.e., C++ references are treated as special pointers.

◆  TUPLE

TUPLE

The data type is a TupleDataType with anonymous members created by ParametricTypes::Tuple.

◆  STRUCT

STRUCT

The data type has an underlying TupleDataType with named members.

◆  SIMD

SIMD

The data type is a SimdElementType. Such a type has a special memory layout where consecutive elements overlap in memory.

◆  BLOCK

BLOCK

The data type is a Block.

◆  STRIDED_BLOCK

STRIDED_BLOCK

The data type is a strided Block.

◆  BASEARRAY

BASEARRAY

The data type is a BaseArray type.

◆  BLOCKARRAY

BLOCKARRAY

The data type is a BlockArray type.

◆  RESULT

RESULT

The data type is a Result.

◆  DELEGATE

DELEGATE

The type is a DelegateDataType.

◆  FUNCTION

FUNCTION

The type is a FunctionDataType (i.e., a GenericFunction bound to input and output types).

◆  CONST_QUALIFIED

CONST_QUALIFIED

The type is const-qualified.

◆  OPAQUE_QUALIFIED

OPAQUE_QUALIFIED

The type is opaque-qualified.

◆  SOURCE_LEVEL

SOURCE_LEVEL

The data type is a type at sourcecode level which is represented by a different architecture- and version-dependent type at runtime.

◆  DEEP_CONSTNESS

DEEP_CONSTNESS

The data type obeys deep constness.

◆  INT_SIZE_OR_LESS

INT_SIZE_OR_LESS

Values of the data type fit into an Int.

◆  ZERO_INITIALIZED

ZERO_INITIALIZED

Values of the data type are initialized with zeroes by their default constructor, also set for scalar types.

◆  ORDERED

ORDERED

Values of the data type are ordered (DataType::Compare can be used and implements a total order).

◆  TRIVIALLY_CONSTRUCTIBLE

TRIVIALLY_CONSTRUCTIBLE

Values of the data type are trivially constructible.

◆  TRIVIALLY_DESTRUCTIBLE

TRIVIALLY_DESTRUCTIBLE

Values of the data type are trivially destructible.

◆  TRIVIALLY_COPYABLE

TRIVIALLY_COPYABLE

Values of the data type are trivially copyable.

◆  TRIVIALLY_EQUATABLE

TRIVIALLY_EQUATABLE

Values of the data type are trivially equatable (see IsTriviallyEquatable).

◆  OBJECT_REF

OBJECT_REF

This flag is set for a reference or pointer to a virtual object.

◆  ELEMENT_TYPE_AS_ARG

ELEMENT_TYPE_AS_ARG

This flag is set for a parametric type which uses the element type to store the type arguments of the instantiation.

◆  NEVER_NULLPTR

NEVER_NULLPTR

This flag is set for pointer or reference types which never hold a nullptr value.

◆  SIGNED

SIGNED

This flag is set for floating point and signed integer types.

◆  GENERIC_INSTANTIATION

GENERIC_INSTANTIATION

The data type is an instantiation of a generic base type for given arguments.

◆  GLOBALLY_REFERENCED

GLOBALLY_REFERENCED

The data type is globally referenced and AddReference() and RemoveReference() should not access its reference counter.

◆  ABSTRACT

ABSTRACT

The data type is an abstract type (for example Generic or an interface type).

◆  NAMED

NAMED

This flag is set for tuple or container types with named members.

◆  CONTAINER_REF

CONTAINER_REF

The data type is a reference type of a container type.

◆  GENERIC_CONTAINER

GENERIC_CONTAINER

This flag may be set for container types to indicate generic members.

◆  RECURSIVE_CONTAINER

RECURSIVE_CONTAINER

The data type represents a recursive container type.

◆  RESOLVED_RECURSIVE_CONTAINER

RESOLVED_RECURSIVE_CONTAINER

The data type represents a resolved recursive container type (i.e. the underlying type points to the enclosing container type).

◆  CONTAINER

CONTAINER

The data type is a ContainerDataType.

◆  EMPTY_CONTAINER

EMPTY_CONTAINER

The data type is a ContainerDataType.

◆  SINGLETON_CONTAINER

SINGLETON_CONTAINER

The data type is a ContainerDataType.

◆  STATIC_ARRAY_CONTAINER

STATIC_ARRAY_CONTAINER

The data type is a ContainerDataType.

◆  ARRAY_CONTAINER

ARRAY_CONTAINER

The data type is a ContainerDataType.

◆  ARRAY

ARRAY

The data type is an ArrayInterface type obtained by DataType::GetArrayType().

The collection is an array.

◆  CONTAINER_MASK

CONTAINER_MASK

The data type is a ContainerDataType.

◆  NAMED_TUPLE

NAMED_TUPLE

The data type is a TupleDataType with named members created by ParametricTypes::Tuple.

◆  CONTAINS_RECURSIVE_CONTAINER

CONTAINS_RECURSIVE_CONTAINER

The data type directly or indirectly contains a recursive container type.

◆  MIN_DERIVED_CONTAINER

MIN_DERIVED_CONTAINER

◆  MIN_ARRAY_CONTAINER

MIN_ARRAY_CONTAINER

◆  MAX_ARRAY_CONTAINER

MAX_ARRAY_CONTAINER

◆  COW_MASK

COW_MASK

Test mask to check for copy-on-write reference semantics.

◆  STRONG_MASK

STRONG_MASK

Test mask to check for reference counting semantics.

◆  PTR_MASK

PTR_MASK

Test mask any kind of pointer/reference.

◆  CONTAINER_OR_REF

CONTAINER_OR_REF

◆  REFERENCE_MASK

REFERENCE_MASK

◆  ARITHMETIC_MASK

ARITHMETIC_MASK

Test mask for concrete arithmetic types.

◆  TUPLE_MASK

TUPLE_MASK

◆  TUPLE_INHERIT_MASK

TUPLE_INHERIT_MASK

◆  POINTER_FLAGS

POINTER_FLAGS

The VALUEKIND of a pointer.

◆  QUALIFIER_MASK

QUALIFIER_MASK

◆  SET

SET

The collection is a set.

◆  MAP

MAP

< The collection is a map.

MAXON_PREPROCESSOR_CONDITION
MAXON_PREPROCESSOR_CONDITION(defined(MAXON_TARGET_WINDOWS))