apibase.h File Reference

Detailed Description

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  MakeLValueConst< T >
 
struct  MakeLValueConst< 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 >
 
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_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 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,
  NAMED_TUPLE,
  STRUCT,
  SIMD,
  BLOCK,
  STRIDED_BLOCK,
  ARRAY,
  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,
  CONTAINER,
  EMPTY_CONTAINER,
  SINGLETON_CONTAINER,
  STATIC_ARRAY_CONTAINER,
  ARRAY_CONTAINER,
  CONTAINER_MASK,
  MIN_DERIVED_CONTAINER,
  MIN_ARRAY_CONTAINER,
  MAX_ARRAY_CONTAINER,
  CONTAINER_REF,
  GENERIC_CONTAINER,
  RECURSIVE_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
}
 

Functions

 __attribute__ ((always_inline)) typename std
 
constexpr UInt UIntPow (UInt x, Int exp)
 
constexpr UInt PrivateGetHashCode (const char *str, Int len)
 
constexpr UInt PrivateGetHashCode (const Utf32Char *str, Int len)
 
const StringStringInterface_GetAndCacheConstString (const wchar_t *str, Int len)
 
const StringStringInterface_GetAndCacheConstString (const Char *str, Int len, Int isUtf8)
 
constexpr Bool PrivateIsUtf8 (const char *str, Int len)
 
const Stringoperator""_s (const char *str, std::size_t cnt)
 
const Stringoperator""_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 >
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 Reset (T &object)
 
constexpr maxon::Float operator""_f (long double f)
 

Variables

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
 
 NAMED_TUPLE
 
 STRUCT
 
 SIMD
 
 BLOCK
 
 STRIDED_BLOCK
 
 ARRAY
 
 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
 
 CONTAINER
 
 EMPTY_CONTAINER
 
 SINGLETON_CONTAINER
 
 STATIC_ARRAY_CONTAINER
 
 ARRAY_CONTAINER
 
 CONTAINER_MASK
 
 MIN_DERIVED_CONTAINER
 
 MIN_ARRAY_CONTAINER
 
 MAX_ARRAY_CONTAINER
 
 CONTAINER_REF
 
 GENERIC_CONTAINER
 
 RECURSIVE_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)

Use 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.

◆ NAMED_TUPLE

NAMED_TUPLE

The data type is a TupleDataType with named 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.

◆ ARRAY

ARRAY

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

The collection is an array.

◆ 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).

◆ 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.

◆ CONTAINER_MASK

CONTAINER_MASK

The data type is a ContainerDataType.

◆ MIN_DERIVED_CONTAINER

MIN_DERIVED_CONTAINER

◆ MIN_ARRAY_CONTAINER

MIN_ARRAY_CONTAINER

◆ MAX_ARRAY_CONTAINER

MAX_ARRAY_CONTAINER

◆ 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 member, its underlying type is the true container type.

◆ 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))