Detailed Description

Groups
	GRADIENT_INTERPOLATION_TYPE

	SPLINEMAPPER_INTERPOLATION_TYPE

	SPLINEMAPPER_KNOT_FLAGS

	SPLINEMAPPER_RANGE_STATE

	SPLINEMAPPER_SPLINE_TYPE

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	GenericComponent

class	Result< RESULT_TYPE >

class	ResultOk< T >

class	EmptyClass

class	EmptyVirtualClass

class	SFINAEHelper< T, CHECK >

struct	is_constructible< maxon::Generic, const maxon::Generic & >

class	ThreadReferencedError

struct	TestForCopyFromMember< T >

class	ObjectConstructor< T, hasCopyFrom >

class	ObjectConstructor< T, false >

struct	HasInit< DETECTORINPUTTYPE >

struct	AlignedStorage< SIZE, ALIGN >

class	DefaultLValue< VALUETYPE >

class	DataDictionaryInterface

class	DataDictionaryIteratorInterface

class	DataDictionaryIterator

class	DataDictionaryObjectInterface

class	DataDictionaryReferenceObjectInterface

class	UnregisteredDataTypeErrorInterface

struct	IsSimdElementType< T, CHECK >

struct	IsSimdElementType< T, typename SFINAEHelper< void, typename T::VectorStrideType >::type >

struct	SimdInfo

class	SimdBlock< T >

struct	AInt

struct	AUInt

struct	AFloat

struct	CheckedGetDataType< T, POLICY, QUALIFIED >

class	DataTypeCache

class	DataTypeCacheInstance< T, POLICY, ELEMENTARY >

class	DataTypeCacheInstance< T, POLICY, true >

class	DataTypeCacheInstance< void, POLICY, true >

class	DataTypeCacheInstance< std::nullptr_t, POLICY, true >

class	DataTypeCacheInstance< InvalidType, POLICY, true >

struct	NamedTupleMembers

class	NamedTuple< T >

class	TupleValue

class	FunctionDataType

struct	DataMemBlock

class	Opt< T >

class	DataTypePtr

class	DataTypeImpl

class	DataTypeImpl::Primary

class	DataTypeImpl::Instantiated

class	DataType

class	DataType::Primary

class	Data

struct	IsZeroInitialized< Data >

class	ConstDataPtr

class	ConstDataPtr::Wrapper< T, CHECK >

class	DataPtr

class	MoveDataPtr

struct	ForwardingDataPtr

class	TrivialDataPtr

class	AbstractDataTypeFunctions

class	DataTypeReferenceFunctions< T, SUPER >

class	DefaultDataTypeFunctionsBase< T >

class	DefaultDataTypeFunctions< T, TYPE >

class	DefaultDataTypeFunctions< T, DATATYPEMODE::SMALLISPOD >

class	DefaultDataTypeFunctions< T, DATATYPEMODE::SMALL >

class	DefaultDataTypeFunctions< T, DATATYPEMODE::BIG >

struct	DefaultDataTypeFunctionsCapabilityFlags< T >

class	DataTypeFunctions< T >

class	InterfaceDataTypeFunctions< T >

class	InternedId

struct	IsTriviallyEquatable< InternedId >

struct	IsZeroInitialized< InternedId >

class	InternedIdPtr

struct	IsTriviallyEquatable< InternedIdPtr >

struct	IsZeroInitialized< InternedIdPtr >

struct	Member

struct	TypeArguments

class	DataTypeLib

class	TupleDataType

class	DelegateDataType

class	EnumDataType

class	ContainerDataType< T >

class	ResultMemT< T >

class	LiteralId

class	Id

class	CompareTemplate< ALLOW_UNDEFINED, EQ, OPERATOR_RANK >

class	DefaultCompare

class	EqualityCompare

class	CStringCompare

class	RefCompare< COW, IS_INTERFACE >

class	RefCompare< true, false >

class	RefCompare< true, true >

class	BigIntegerInterface

class	BigInteger

struct	GradientKnot

class	GradientInterface

class	GradientRenderDataInterface

struct	SplineMapperKnot

class	SplineMapperInterface

Macros
#define	MAXON_ATTRIBUTE_DLL_PUBLIC

#define	MAXON_ATTRIBUTE_NO_INLINE

#define	MAXON_ATTRIBUTE_FORCE_INLINE

#define	MAXON_ATTRIBUTE_FORCE_RELEASE_INLINE

#define	MAXON_ATTRIBUTE_USED

#define	MAXON_HAS_ATTRIBUTE_ALWAYS_CONST

#define	MAXON_ATTRIBUTE_ALWAYS_CONST

#define	MAXON_ATTRIBUTE_ALWAYS_PURE

#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	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_SCOPE

#define	MAXON_WARN_MUTE_FUNCTION_LENGTH

#define	MAXON_WARN_MUTE_NAMING

#define	PRIVATE_MAXON_DATATYPE_A(type, id, ...)

#define	PRIVATE_MAXON_DATATYPE(type, id, ...)

#define	MAXON_DATATYPE(type, id, ...)

#define	PRIVATE_MAXON_DATATYPE_REGISTER(T, ret, flags)

#define	PRIVATE_MAXON_DATATYPE_REGISTER_ENUM(enumtype, cppname, id, size, flags, names, ...)

#define	MAXON_DATATYPE_REGISTER(type)

#define	PRIVATE_MAXON_DATATYPE_LOCAL_STATIC

#define	MAXON_DATATYPE_LOCAL(type, id)

#define	PRIVATE_MAXON_DATATYPE_REGISTER_STRUCT_INIT(x, i, a)

#define	PRIVATE_MAXON_DATATYPE_REGISTER_STRUCT_OFFSETS(x, i, a)

#define	PRIVATE_MAXON_DATATYPE_REGISTER_STRUCT_B(Type, line, count, ...)

#define	PRIVATE_MAXON_DATATYPE_REGISTER_STRUCT_A(type, line, count, ...)

#define	MAXON_DATATYPE_REGISTER_STRUCT(type, ...)

#define	SPLINEMAPPER_KNOT_GET_ID(flags)

#define	SPLINEMAPPER_KNOT_SET_ID(flags, flag_id)

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	Byte = std::byte

using	Utf32Char = char32_t

using	Utf16Char = char16_t

using	SysChar = char

using	type = Char

using	type = Int16

using	type = Int32

using	type = Int64

using	type = UChar

using	type = UInt16

using	type = UInt32

using	type = UInt64

using	type = T

using	DT = typename std::decay< T >::type

using	type = typename std::conditional< KEEP, T, typename std::conditional< STD_IS_REPLACEMENT(signed, T), typename IntType< sizeof(T)>::type, typename UIntType< sizeof(T)>::type >::type >::type

using	HashInt = UInt

using	type = T

using	InitMTable = void(*)()

using	DestructorPointer = void()(const void )

using	BoolLValue = DefaultLValue< Bool >

using	ResultMem = ResultMemT< Bool >

Enumerations
enum class	ENUM_DONT_INITIALIZE { VALUE }

enum class	IN_PLACE_TYPE { VALUE }

enum class	CONVERSION_FLAGS { NONE , NARROWING , WIDENING_LOSSY , WIDENING_LOSSLESS , REDUCING , EXPANDING , STRUCT_CAST , ITERATION , INCONVERTIBLE , WIDENING_MASK , NARROWING_REDUCING_MASK }

enum class	GET_DATATYPE_POLICY { NONE , GENERIC_FOR_UNKNOWN , ERROR_FOR_UNKNOWN , RESULT_FOR_UNKNOWN_MASK }

enum class	DATATYPEMODE { SMALLISPOD , SMALL , BIG }

enum class	INNERMOST_MEMBER : Int32

enum class	COMPARERESULT : int { LESS , EQUAL , GREATER , INCOMPARABLE }

enum class	EQUALITY { SHALLOW , DEEP }

Functions
	__attribute__ ((always_inline)) const expr Float operator""_f(long double f)

template<typename T >
	__attribute__ ((always_inline)) auto AssignCopy(T &dst

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)

template<typename T >
String	GlobalToString (const T &object, const FormatStatement *formatStatement, Bool checkDataType=true)

virtual	~EmptyVirtualClass ()

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)

	Helper (OverloadRank2, T &obj MAXON_MAKE_LIST(PRIVATE_MAXON_DETECT_MEMBER_HELPER1,,,,)) -> decltype(obj. GetMemorySize(MAXON_MAKE_COMMA_LIST(PRIVATE_MAXON_DETECT_MEMBER_HELPER2,,,)))

	Helper (OverloadRank1, T &obj MAXON_MAKE_LIST(PRIVATE_MAXON_DETECT_MEMBER_HELPER1,,,,)) -> decltype(GetMemorySize(obj MAXON_MAKE_LIST(PRIVATE_MAXON_DETECT_MEMBER_HELPER3,,,,)))

	Helper (T &obj MAXON_MAKE_LIST(PRIVATE_MAXON_DETECT_MEMBER_HELPER1,,,,)) -> decltype(MAXON_CONCAT(GetMemorySize, Helper)(((maxon::OverloadRankMax) nullptr), obj MAXON_MAKE_LIST(PRIVATE_MAXON_DETECT_MEMBER_HELPER3,,,,)))

template<typename X >
T &	__attribute__ ((always_inline)) void UseVariable(X &&var)

template<typename T >
decltype(std::declval< T >().CopyFrom(std::declval< const T & >()))	TestForCopyFromFunction (OverloadRank1)

template<typename T >
std::false_type	TestForCopyFromFunction (OverloadRank0)

template<typename T , Bool ZEROINITIALIZE = false>
std::enable_if<!std::is_scalar< T >::value, T * >::type	PlacementNew (void *ptr)

template<typename T , Bool ZEROINITIALIZE, typename... ARGS>
T *	PlacementNew (void *ptr, ARGS &&... args)

template<typename T , typename ARG >
	__attribute__ ((always_inline)) auto NewCopy(T &dst

template<typename T >
void	Destruct (const T *object)

template<typename T >
DestructorPointer	GetDestructorPointer ()

template<typename T >
void	Reset (T &object)

template<typename T , typename... ARGS>
static auto	Create (ARGS &&... args)

Result< void >	MergeDataDictionaries (DataDictionary &base, const DataDictionary &other, Bool mergeSubContainers)

Result< void >	MergeDataDictionariesPreferBase (DataDictionary &base, const DataDictionary &other, Bool mergeSubContainers)

Result< Data >	PrivateGetDataDescriptionValue (const Id &databaseScope, const InternedId &attributeData, const ConstDataPtr &keyPtr)

template<typename ATTRIBUTETYPE , typename KEY >
static Result< typename IsFidClass< ATTRIBUTETYPE >::type >	GetDataDescriptionValue (ATTRIBUTETYPE &&attribute, KEY &&key)

template<typename TT , typename ATTRIBUTETYPE >
static Opt< TT >	GetDataDescriptionValue2 (ATTRIBUTETYPE &&attribute, const ConstDataPtr &key)

template<typename ATTRIBUTETYPE , typename KEY >
static Result< typename IsFidClass< KEY >::type >	GetDataDescriptionValueFromKey (ATTRIBUTETYPE &&attribute, KEY &&key)

template<typename TT , typename KEY >
TT	GetDefaultFromFidIfAvailable (KEY &&key, OverloadRank0)

template<typename TT , typename KEY >
SFINAEHelper< TT, decltype(std::remove_reference< KEY >::type::DEFAULTVALUE)>::type	GetDefaultFromFidIfAvailable (KEY &&key, OverloadRank2)

ConstDataPtr	GetDefaultValueKey ()

template<typename SRCCLASS , typename PROPSRCTYPE , typename DSTCLASS , typename PROPDSTTYPE >
Result< void >	TransferPropertyIfAvailable (const SRCCLASS &src, PROPSRCTYPE &&srcType, DSTCLASS &dst, PROPDSTTYPE &&dstType)

	MAXON_DECLARATION (Class< DataDictionaryObjectRef >, DataDictionaryObjectEmptyClass, "net.maxon.class.datadictionaryobjectempty", MAXON_IMPLEMENTATION_MODULE("net.maxon.kernel"))

	MAXON_DECLARATION (Class< DataDictionaryObjectRef >, DataDictionaryObjectClass, "net.maxon.class.datadictionaryobject", MAXON_IMPLEMENTATION_MODULE("net.maxon.kernel"))

	MAXON_DECLARATION (Class< DataDictionaryObjectRef >, DataDictionaryBlockArraySmallObjectClass, "net.maxon.class.datadictionaryblockarraysmallobject", MAXON_IMPLEMENTATION_MODULE("net.maxon.kernel"))

	MAXON_DECLARATION (Class< DataDictionaryObjectRef >, DataDictionaryObjectLockedClass, "net.maxon.class.datadictionaryobjectlocked", MAXON_IMPLEMENTATION_MODULE("net.maxon.kernel"))

	MAXON_DECLARATION (Class< DataDictionaryObjectRef >, DataDictionaryObjectSyncedClass, "net.maxon.class.datadictionaryobjectsynced", MAXON_IMPLEMENTATION_MODULE("net.maxon.kernel"))

	MAXON_DECLARATION (Class< DataDictionaryReferenceObjectRef >, DataDictionaryObjectReferenceClass, "net.maxon.class.datadictionaryobjectreference", MAXON_IMPLEMENTATION_MODULE("net.maxon.kernel"))

Result< DataDictionaryObjectRef >	CreateDataDictionaryReferenceObject (DataDictionary *reference)

Result< DataDictionaryObjectRef >	CreateDataDictionaryReferenceObject (const DataDictionary *reference)

Result< DataDictionary >	GetDataDictionaryFromDataDictionaryObjectRef (const DataDictionaryObjectRef &ref)

template<GET_DATATYPE_POLICY POLICY>
ResultOk< const DataType & >	PrivateGetDataType (GenericArithmetic **, OverloadRank0)

template<GET_DATATYPE_POLICY POLICY>
ResultOk< const DataType & >	PrivateGetDataType (void **, OverloadRank0)

template<GET_DATATYPE_POLICY POLICY>
ResultOk< const DataType & >	PrivateGetDataType (std::nullptr_t **, OverloadRank0)

template<GET_DATATYPE_POLICY POLICY>
ResultOk< const DataType & >	PrivateGetDataType (InvalidType **, OverloadRank0)

template<GET_DATATYPE_POLICY POLICY, typename T >
SFINAEHelper< Result< const DataType & >, typename T::NonvirtualInterfaceMarker >::type	PrivateGetDataType (T **, OverloadRank0)

template<GET_DATATYPE_POLICY POLICY, typename T >
SFINAEHelper< Result< const DataType & >, typename T::InterfaceMarker >::type	PrivateGetDataType (T **, OverloadRank1)

template<GET_DATATYPE_POLICY POLICY>
Result< const DataType & >	PrivateGetDataType (void *, OverloadRank0)

template<GET_DATATYPE_POLICY POLICY>
ResultOk< const DataType & >	PrivateGetDataType (DataType **, OverloadRank0)

template<GET_DATATYPE_POLICY POLICY>
ResultOk< const DataType & >	PrivateGetDataType (DataType::Primary **, OverloadRank0)

template<GET_DATATYPE_POLICY POLICY>
ResultOk< const DataType & >	PrivateGetDataType (TupleDataType **, OverloadRank0)

template<typename T >
void	PrivateDataTypeMarker (T *)

	MAXON_REGISTRY (DataType, DataTypes, "net.maxon.registry.datatypes")

void *	PrivateDataTypeMarker (Char *)

	MAXON_DECLARATION (maxon::DataType, DT_Char, "char", static constexpr maxon::EntityBase::TYPE TYPE=maxon::EntityBase::TYPE::DATATYPE;MAXON_IMPLEMENTATION_MODULE("net.maxon.kernel"))

template<maxon::GET_DATATYPE_POLICY >
maxon::ResultOk< const maxon::DataType & >	PrivateGetDataType (Char **, maxon::OverloadRank2)

	MAXON_ASSERT_LEGAL_LAYOUT (Char)

void *	PrivateDataTypeMarker (UChar *)

	MAXON_DECLARATION (maxon::DataType, DT_UChar, "uchar", static constexpr maxon::EntityBase::TYPE TYPE=maxon::EntityBase::TYPE::DATATYPE;MAXON_IMPLEMENTATION_MODULE("net.maxon.kernel"))

template<maxon::GET_DATATYPE_POLICY >
maxon::ResultOk< const maxon::DataType & >	PrivateGetDataType (UChar **, maxon::OverloadRank2)

	MAXON_ASSERT_LEGAL_LAYOUT (UChar)

void *	PrivateDataTypeMarker (Int16 *)

	MAXON_DECLARATION (maxon::DataType, DT_Int16, "int16", static constexpr maxon::EntityBase::TYPE TYPE=maxon::EntityBase::TYPE::DATATYPE;MAXON_IMPLEMENTATION_MODULE("net.maxon.kernel"))

template<maxon::GET_DATATYPE_POLICY >
maxon::ResultOk< const maxon::DataType & >	PrivateGetDataType (Int16 **, maxon::OverloadRank2)

	MAXON_ASSERT_LEGAL_LAYOUT (Int16)

void *	PrivateDataTypeMarker (UInt16 *)

	MAXON_DECLARATION (maxon::DataType, DT_UInt16, "uint16", static constexpr maxon::EntityBase::TYPE TYPE=maxon::EntityBase::TYPE::DATATYPE;MAXON_IMPLEMENTATION_MODULE("net.maxon.kernel"))

template<maxon::GET_DATATYPE_POLICY >
maxon::ResultOk< const maxon::DataType & >	PrivateGetDataType (UInt16 **, maxon::OverloadRank2)

	MAXON_ASSERT_LEGAL_LAYOUT (UInt16)

void *	PrivateDataTypeMarker (Int32 *)

	MAXON_DECLARATION (maxon::DataType, DT_Int32, "int32", static constexpr maxon::EntityBase::TYPE TYPE=maxon::EntityBase::TYPE::DATATYPE;MAXON_IMPLEMENTATION_MODULE("net.maxon.kernel"))

template<maxon::GET_DATATYPE_POLICY >
maxon::ResultOk< const maxon::DataType & >	PrivateGetDataType (Int32 **, maxon::OverloadRank2)

	MAXON_ASSERT_LEGAL_LAYOUT (Int32)

void *	PrivateDataTypeMarker (UInt32 *)

	MAXON_DECLARATION (maxon::DataType, DT_UInt32, "uint32", static constexpr maxon::EntityBase::TYPE TYPE=maxon::EntityBase::TYPE::DATATYPE;MAXON_IMPLEMENTATION_MODULE("net.maxon.kernel"))

template<maxon::GET_DATATYPE_POLICY >
maxon::ResultOk< const maxon::DataType & >	PrivateGetDataType (UInt32 **, maxon::OverloadRank2)

	MAXON_ASSERT_LEGAL_LAYOUT (UInt32)

void *	PrivateDataTypeMarker (Int64 *)

	MAXON_DECLARATION (maxon::DataType, DT_Int64, "int64", static constexpr maxon::EntityBase::TYPE TYPE=maxon::EntityBase::TYPE::DATATYPE;MAXON_IMPLEMENTATION_MODULE("net.maxon.kernel"))

template<maxon::GET_DATATYPE_POLICY >
maxon::ResultOk< const maxon::DataType & >	PrivateGetDataType (Int64 **, maxon::OverloadRank2)

	MAXON_ASSERT_LEGAL_LAYOUT (Int64)

void *	PrivateDataTypeMarker (UInt64 *)

	MAXON_DECLARATION (maxon::DataType, DT_UInt64, "uint64", static constexpr maxon::EntityBase::TYPE TYPE=maxon::EntityBase::TYPE::DATATYPE;MAXON_IMPLEMENTATION_MODULE("net.maxon.kernel"))

template<maxon::GET_DATATYPE_POLICY >
maxon::ResultOk< const maxon::DataType & >	PrivateGetDataType (UInt64 **, maxon::OverloadRank2)

	MAXON_ASSERT_LEGAL_LAYOUT (UInt64)

void *	PrivateDataTypeMarker (Utf16Char *)

	MAXON_DECLARATION (maxon::DataType, DT_Utf16Char, "utf16char", static constexpr maxon::EntityBase::TYPE TYPE=maxon::EntityBase::TYPE::DATATYPE;MAXON_IMPLEMENTATION_MODULE("net.maxon.kernel"))

template<maxon::GET_DATATYPE_POLICY >
maxon::ResultOk< const maxon::DataType & >	PrivateGetDataType (Utf16Char **, maxon::OverloadRank2)

	MAXON_ASSERT_LEGAL_LAYOUT (Utf16Char)

void *	PrivateDataTypeMarker (Utf32Char *)

	MAXON_DECLARATION (maxon::DataType, DT_Utf32Char, "utf32char", static constexpr maxon::EntityBase::TYPE TYPE=maxon::EntityBase::TYPE::DATATYPE;MAXON_IMPLEMENTATION_MODULE("net.maxon.kernel"))

template<maxon::GET_DATATYPE_POLICY >
maxon::ResultOk< const maxon::DataType & >	PrivateGetDataType (Utf32Char **, maxon::OverloadRank2)

	MAXON_ASSERT_LEGAL_LAYOUT (Utf32Char)

void *	PrivateDataTypeMarker (Float32 *)

	MAXON_DECLARATION (maxon::DataType, DT_Float32, "float32", static constexpr maxon::EntityBase::TYPE TYPE=maxon::EntityBase::TYPE::DATATYPE;MAXON_IMPLEMENTATION_MODULE("net.maxon.kernel"))

template<maxon::GET_DATATYPE_POLICY >
maxon::ResultOk< const maxon::DataType & >	PrivateGetDataType (Float32 **, maxon::OverloadRank2)

	MAXON_ASSERT_LEGAL_LAYOUT (Float32)

void *	PrivateDataTypeMarker (Float64 *)

	MAXON_DECLARATION (maxon::DataType, DT_Float64, "float64", static constexpr maxon::EntityBase::TYPE TYPE=maxon::EntityBase::TYPE::DATATYPE;MAXON_IMPLEMENTATION_MODULE("net.maxon.kernel"))

template<maxon::GET_DATATYPE_POLICY >
maxon::ResultOk< const maxon::DataType & >	PrivateGetDataType (Float64 **, maxon::OverloadRank2)

	MAXON_ASSERT_LEGAL_LAYOUT (Float64)

void *	PrivateDataTypeMarker (Bool *)

	MAXON_DECLARATION (maxon::DataType, DT_Bool, "bool", static constexpr maxon::EntityBase::TYPE TYPE=maxon::EntityBase::TYPE::DATATYPE;MAXON_IMPLEMENTATION_MODULE("net.maxon.kernel"))

template<maxon::GET_DATATYPE_POLICY >
maxon::ResultOk< const maxon::DataType & >	PrivateGetDataType (Bool **, maxon::OverloadRank2)

	MAXON_ASSERT_LEGAL_LAYOUT (Bool)

void *	PrivateDataTypeMarker (Byte *)

	MAXON_DECLARATION (maxon::DataType, DT_Byte, "byte", static constexpr maxon::EntityBase::TYPE TYPE=maxon::EntityBase::TYPE::DATATYPE;MAXON_IMPLEMENTATION_MODULE("net.maxon.kernel"))

template<maxon::GET_DATATYPE_POLICY >
maxon::ResultOk< const maxon::DataType & >	PrivateGetDataType (Byte **, maxon::OverloadRank2)

	MAXON_ASSERT_LEGAL_LAYOUT (Byte)

void *	PrivateDataTypeMarker (AInt *)

	MAXON_DECLARATION (maxon::DataType, DT_AInt, "int", static constexpr maxon::EntityBase::TYPE TYPE=maxon::EntityBase::TYPE::DATATYPE;MAXON_IMPLEMENTATION_MODULE("net.maxon.kernel"))

template<maxon::GET_DATATYPE_POLICY >
maxon::ResultOk< const maxon::DataType & >	PrivateGetDataType (AInt **, maxon::OverloadRank2)

	MAXON_ASSERT_LEGAL_LAYOUT (AInt)

void *	PrivateDataTypeMarker (AUInt *)

	MAXON_DECLARATION (maxon::DataType, DT_AUInt, "uint", static constexpr maxon::EntityBase::TYPE TYPE=maxon::EntityBase::TYPE::DATATYPE;MAXON_IMPLEMENTATION_MODULE("net.maxon.kernel"))

template<maxon::GET_DATATYPE_POLICY >
maxon::ResultOk< const maxon::DataType & >	PrivateGetDataType (AUInt **, maxon::OverloadRank2)

	MAXON_ASSERT_LEGAL_LAYOUT (AUInt)

void *	PrivateDataTypeMarker (AFloat *)

	MAXON_DECLARATION (maxon::DataType, DT_AFloat, "float", static constexpr maxon::EntityBase::TYPE TYPE=maxon::EntityBase::TYPE::DATATYPE;MAXON_IMPLEMENTATION_MODULE("net.maxon.kernel"))

template<maxon::GET_DATATYPE_POLICY >
maxon::ResultOk< const maxon::DataType & >	PrivateGetDataType (AFloat **, maxon::OverloadRank2)

	MAXON_ASSERT_LEGAL_LAYOUT (AFloat)

void *	PrivateDataTypeMarker (UniqueHash *)

	MAXON_DECLARATION (maxon::DataType, DT_UniqueHash, "net.maxon.datatype.hash", static constexpr maxon::EntityBase::TYPE TYPE=maxon::EntityBase::TYPE::DATATYPE;MAXON_IMPLEMENTATION_MODULE("net.maxon.kernel"))

template<maxon::GET_DATATYPE_POLICY >
maxon::ResultOk< const maxon::DataType & >	PrivateGetDataType (UniqueHash **, maxon::OverloadRank2)

	MAXON_ASSERT_LEGAL_LAYOUT (UniqueHash)

void *	PrivateDataTypeMarker (Id *)

	MAXON_DECLARATION (maxon::DataType, DT_Id, "net.maxon.datatype.id", static constexpr maxon::EntityBase::TYPE TYPE=maxon::EntityBase::TYPE::DATATYPE;MAXON_IMPLEMENTATION_MODULE("net.maxon.kernel"))

template<maxon::GET_DATATYPE_POLICY >
maxon::ResultOk< const maxon::DataType & >	PrivateGetDataType (Id **, maxon::OverloadRank2)

	MAXON_ASSERT_LEGAL_LAYOUT (Id)

void *	PrivateDataTypeMarker (LiteralId *)

	MAXON_DECLARATION (maxon::DataType, DT_LiteralId, "net.maxon.datatype.literalid", static constexpr maxon::EntityBase::TYPE TYPE=maxon::EntityBase::TYPE::DATATYPE;MAXON_IMPLEMENTATION_MODULE("net.maxon.kernel"))

template<maxon::GET_DATATYPE_POLICY >
maxon::ResultOk< const maxon::DataType & >	PrivateGetDataType (LiteralId **, maxon::OverloadRank2)

	MAXON_ASSERT_LEGAL_LAYOUT (LiteralId)

void *	PrivateDataTypeMarker (InternedId *)

	MAXON_DECLARATION (maxon::DataType, DT_InternedId, "net.maxon.datatype.internedid", static constexpr maxon::EntityBase::TYPE TYPE=maxon::EntityBase::TYPE::DATATYPE;MAXON_IMPLEMENTATION_MODULE("net.maxon.kernel"))

template<maxon::GET_DATATYPE_POLICY >
maxon::ResultOk< const maxon::DataType & >	PrivateGetDataType (InternedId **, maxon::OverloadRank2)

	MAXON_ASSERT_LEGAL_LAYOUT (InternedId)

void *	PrivateDataTypeMarker (Data *)

	MAXON_DECLARATION (maxon::DataType, DT_Data, "net.maxon.datatype.data", static constexpr maxon::EntityBase::TYPE TYPE=maxon::EntityBase::TYPE::DATATYPE;MAXON_IMPLEMENTATION_MODULE("net.maxon.kernel"))

template<maxon::GET_DATATYPE_POLICY >
maxon::ResultOk< const maxon::DataType & >	PrivateGetDataType (Data **, maxon::OverloadRank2)

	MAXON_ASSERT_LEGAL_LAYOUT (Data)

void *	PrivateDataTypeMarker (UnitType *)

	MAXON_DECLARATION (maxon::DataType, DT_UnitType, "net.maxon.datatype.unittype", static constexpr maxon::EntityBase::TYPE TYPE=maxon::EntityBase::TYPE::DATATYPE;MAXON_IMPLEMENTATION_MODULE("net.maxon.kernel"))

template<maxon::GET_DATATYPE_POLICY >
maxon::ResultOk< const maxon::DataType & >	PrivateGetDataType (UnitType **, maxon::OverloadRank2)

	MAXON_ASSERT_LEGAL_LAYOUT (UnitType)

void *	PrivateDataTypeMarker (SourceLocation *)

	MAXON_DECLARATION (maxon::DataType, DT_SourceLocation, "net.maxon.datatype.sourcelocation", static constexpr maxon::EntityBase::TYPE TYPE=maxon::EntityBase::TYPE::DATATYPE;MAXON_IMPLEMENTATION_MODULE("net.maxon.kernel"))

template<maxon::GET_DATATYPE_POLICY >
maxon::ResultOk< const maxon::DataType & >	PrivateGetDataType (SourceLocation **, maxon::OverloadRank2)

	MAXON_ASSERT_LEGAL_LAYOUT (SourceLocation)

void *	PrivateDataTypeMarker (DelegateBase *)

	MAXON_DECLARATION (maxon::DataType, DT_DelegateBase, "net.maxon.datatype.delegatebase", static constexpr maxon::EntityBase::TYPE TYPE=maxon::EntityBase::TYPE::DATATYPE;MAXON_IMPLEMENTATION_MODULE("net.maxon.kernel"))

template<maxon::GET_DATATYPE_POLICY >
maxon::ResultOk< const maxon::DataType & >	PrivateGetDataType (DelegateBase **, maxon::OverloadRank2)

	MAXON_ASSERT_LEGAL_LAYOUT (DelegateBase)

template<Bool , typename T >
ResultOk< const DataType & >	PrivateGetEnumDataType (T *, OverloadRank0)

template<GET_DATATYPE_POLICY POLICY>
ResultOk< const DataType & >	PrivateGetDataType (long **, OverloadRank0)

template<GET_DATATYPE_POLICY POLICY>
ResultOk< const DataType & >	PrivateGetDataType (unsigned long **, OverloadRank0)

template<GET_DATATYPE_POLICY POLICY>
ResultOk< const DataType & >	PrivateGetDataType (ParametricType **, OverloadRank0)

template<GET_DATATYPE_POLICY POLICY>
ResultOk< const DataType & >	PrivateGetDataType (ComponentDescriptor **, OverloadRank0)

template<GET_DATATYPE_POLICY POLICY, typename T >
Result< DataType >	PrivateGetDataType (T ***, OverloadRank0)

template<GET_DATATYPE_POLICY POLICY, typename T >
Result< DataType >	PrivateGetDataType (Block< T > **, OverloadRank0)

template<GET_DATATYPE_POLICY POLICY, typename T >
Result< DataType >	PrivateGetDataType (StridedBlock< T > **, OverloadRank0)

template<GET_DATATYPE_POLICY POLICY, typename T >
Result< DataType >	PrivateGetDataType (Opt< T > **, OverloadRank0)

template<GET_DATATYPE_POLICY POLICY, typename T >
Result< DataType >	PrivateGetDataType (Result< T > **, OverloadRank0)

template<GET_DATATYPE_POLICY POLICY>
Result< DataType >	PrivateGetDataType (AtomicBool **, OverloadRank0)

template<GET_DATATYPE_POLICY POLICY, typename T >
Result< DataType >	PrivateGetDataType (Atomic8< T > **, OverloadRank0)

template<GET_DATATYPE_POLICY POLICY, typename T >
Result< DataType >	PrivateGetDataType (Atomic16< T > **, OverloadRank0)

template<GET_DATATYPE_POLICY POLICY, typename T >
Result< DataType >	PrivateGetDataType (Atomic32< T > **, OverloadRank0)

template<GET_DATATYPE_POLICY POLICY, typename T >
Result< DataType >	PrivateGetDataType (Atomic64< T > **, OverloadRank0)

template<GET_DATATYPE_POLICY POLICY, typename T >
Result< DataType >	PrivateGetDataType (AtomicPtr< T > **, OverloadRank0)

template<GET_DATATYPE_POLICY POLICY, typename T >
Result< DataType >	PrivateGetDataType (AtomicFloatType< T > **, OverloadRank0)

template<GET_DATATYPE_POLICY POLICY, typename T >
Result< DataType >	PrivateGetDataType (BaseArray< T > **, OverloadRank0)

template<GET_DATATYPE_POLICY POLICY, typename... T>
Result< TupleDataType >	PrivateGetDataType (Tuple< T... > **, OverloadRank0)

template<GET_DATATYPE_POLICY POLICY, typename T , typename = typename T::StructTupleType>
Result< TupleDataType >	PrivateGetDataType (T **, OverloadRank0)

template<GET_DATATYPE_POLICY POLICY, typename R , typename... ARGS>
Result< DelegateDataType >	PrivateGetDataType (Delegate< R(ARGS...)> **, OverloadRank2)

template<typename T , GET_DATATYPE_POLICY POLICY>
const auto &	GetDataType ()

template<GET_DATATYPE_POLICY POLICY>
ResultOk< const DataType & >	PrivateGetDataType (Generic **, OverloadRank0)

void *	PrivateDataTypeMarker (ConstDataPtr *)

	MAXON_DECLARATION (maxon::DataType, DT_ConstDataPtr, "net.maxon.datatype.constdataptr", static constexpr maxon::EntityBase::TYPE TYPE=maxon::EntityBase::TYPE::DATATYPE;MAXON_IMPLEMENTATION_MODULE("net.maxon.kernel"))

template<maxon::GET_DATATYPE_POLICY >
maxon::ResultOk< const maxon::DataType & >	PrivateGetDataType (ConstDataPtr **, maxon::OverloadRank2)

	MAXON_ASSERT_LEGAL_LAYOUT (ConstDataPtr)

void *	PrivateDataTypeMarker (TrivialDataPtr *)

	MAXON_DECLARATION (maxon::DataType, DT_TrivialDataPtr, "net.maxon.datatype.trivialdataptr", static constexpr maxon::EntityBase::TYPE TYPE=maxon::EntityBase::TYPE::DATATYPE;MAXON_IMPLEMENTATION_MODULE("net.maxon.kernel"))

template<maxon::GET_DATATYPE_POLICY >
maxon::ResultOk< const maxon::DataType & >	PrivateGetDataType (TrivialDataPtr **, maxon::OverloadRank2)

	MAXON_ASSERT_LEGAL_LAYOUT (TrivialDataPtr)

void *	PrivateDataTypeMarker (DataPtr *)

	MAXON_DECLARATION (maxon::DataType, DT_DataPtr, "net.maxon.datatype.dataptr", static constexpr maxon::EntityBase::TYPE TYPE=maxon::EntityBase::TYPE::DATATYPE;MAXON_IMPLEMENTATION_MODULE("net.maxon.kernel"))

template<maxon::GET_DATATYPE_POLICY >
maxon::ResultOk< const maxon::DataType & >	PrivateGetDataType (DataPtr **, maxon::OverloadRank2)

	MAXON_ASSERT_LEGAL_LAYOUT (DataPtr)

void *	PrivateDataTypeMarker (MoveDataPtr *)

	MAXON_DECLARATION (maxon::DataType, DT_MoveDataPtr, "net.maxon.datatype.movedataptr", static constexpr maxon::EntityBase::TYPE TYPE=maxon::EntityBase::TYPE::DATATYPE;MAXON_IMPLEMENTATION_MODULE("net.maxon.kernel"))

template<maxon::GET_DATATYPE_POLICY >
maxon::ResultOk< const maxon::DataType & >	PrivateGetDataType (MoveDataPtr **, maxon::OverloadRank2)

	MAXON_ASSERT_LEGAL_LAYOUT (MoveDataPtr)

void *	PrivateDataTypeMarker (ForwardingDataPtr *)

	MAXON_DECLARATION (maxon::DataType, DT_ForwardingDataPtr, "net.maxon.datatype.forwardingdataptr", static constexpr maxon::EntityBase::TYPE TYPE=maxon::EntityBase::TYPE::DATATYPE;MAXON_IMPLEMENTATION_MODULE("net.maxon.kernel"))

template<maxon::GET_DATATYPE_POLICY >
maxon::ResultOk< const maxon::DataType & >	PrivateGetDataType (ForwardingDataPtr **, maxon::OverloadRank2)

	MAXON_ASSERT_LEGAL_LAYOUT (ForwardingDataPtr)

void *	PrivateDataTypeMarker (Member *)

	MAXON_DECLARATION (maxon::DataType, DT_Member, "net.maxon.datatype.member", static constexpr maxon::EntityBase::TYPE TYPE=maxon::EntityBase::TYPE::DATATYPE;MAXON_IMPLEMENTATION_MODULE("net.maxon.kernel"))

template<maxon::GET_DATATYPE_POLICY >
maxon::ResultOk< const maxon::DataType & >	PrivateGetDataType (Member **, maxon::OverloadRank2)

	MAXON_ASSERT_LEGAL_LAYOUT (Member)

template<GET_DATATYPE_POLICY POLICY, typename... T>
Result< TupleDataType >	PrivateGetDataType (NamedTuple< T... > **, OverloadRank0)

template<GET_DATATYPE_POLICY POLICY, typename T , T C>
Result< DataType >	PrivateGetDataType (std::integral_constant< T, C > **, OverloadRank0)

enum maxon::CONVERSION_FLAGS	MAXON_ENUM_FLAGS (CONVERSION_FLAGS)

enum maxon::GET_DATATYPE_POLICY	MAXON_ENUM_FLAGS (GET_DATATYPE_POLICY)

Bool	operator== (const ForwardingDataPtr &a, const Data &b)

Bool	operator!= (const ForwardingDataPtr &a, const Data &b)

	MAXON_DETECT_MEMBER_HELPER (DescribeIO, const DataSerializeInterface &)

template<typename T >
Result< void >	DescribeIO (const T &s, const DataSerializeInterface &dsi)

enum maxon::DATATYPEMODE	MAXON_ENUM_LIST (DATATYPEMODE)

Result< void * >	DecltypeNewInstanceHelper (const void *)

template<typename T >
static Result< void * >	PrivateNewInterfaceInstance (OverloadRank0)

template<typename T >
static decltype(DecltypeNewInstanceHelper(T::Alloc(maxon::SourceLocation()))) MAXON_WARN_UNUSED	PrivateNewInterfaceInstance (OverloadRank1)

enum maxon::INNERMOST_MEMBER Int32	MAXON_ENUM_ORDERED_LIST (INNERMOST_MEMBER)

enum maxon::COMPARERESULT int	MAXON_ENUM_ORDERED_LIST (COMPARERESULT, "net.maxon.datatype.enum.compareresult", EARLY)

Bool	operator== (COMPARERESULT a, int b)

Bool	operator< (COMPARERESULT a, int b)

enum maxon::EQUALITY	MAXON_ENUM_LIST (EQUALITY, "net.maxon.datatype.enum.equality", EARLY)

template<Bool ALLOW_UNDEFINED = false>
Bool	LexicographicalGreaterThan ()

template<Bool ALLOW_UNDEFINED = false, typename T1 , typename... TN>
Bool	LexicographicalGreaterThan (const T1 &a1, const T1 &b1, const TN &... ab)

template<Bool ALLOW_UNDEFINED = false>
Bool	LexicographicalLessThan ()

template<Bool ALLOW_UNDEFINED = false, typename T1 , typename... TN>
Bool	LexicographicalLessThan (const T1 &a1, const T1 &b1, const TN &... ab)

template<Bool ALLOW_UNDEFINED = false>
COMPARERESULT	LexicographicalCompare ()

template<Bool ALLOW_UNDEFINED = false, typename T1 , typename... TN>
COMPARERESULT	LexicographicalCompare (const T1 &a1, const T1 &b1, const TN &... ab)

	MAXON_DATATYPE (GradientKnot, "net.maxon.datatype.gradientknot")

COMPARERESULT	Compare (const GradientKnot &a, const GradientKnot &b)

	MAXON_DATATYPE (SplineMapperKnot, "net.maxon.datatype.splinemapperknot")

	DataDictionaryIterator (const DataDictionaryInterface *dict, Bool end)

template<typename T , typename KEY >
std::conditional< std::is_void< T >::value, typename IsFidClass< KEY >::type, T >::type	GetOrDefault (KEY &&key) const

	DataDictionaryIterator (const DataDictionaryObjectInterface *dict, Bool end)

template<typename T , typename KEY >
std::conditional< std::is_void< T >::value, typename IsFidClass< KEY >::type, T >::type	GetOrDefault (KEY &&key) const

template<typename T >
void	AssertType () const

template<typename T >
Bool	Is () const

template<typename DEST , typename SRC >
Result< void >	AddConversion (CONVERSION_FLAGS kind, Result< void >(*conversion)(DEST &, const SRC &))

template<typename T >
Bool	IsCastableFrom () const

template<typename T >
Bool	IsCastableTo () const

template<typename T >
static Result< Data >	Create ()

Result< Data >	GetCopy () const

template<typename T >
void	InitSet (T &&data)

template<>
void	InitSet (Data &&data)

template<typename DEST , typename SRC >
Result< void >	SetImpl (SRC &&data, OverloadRank0)

template<typename DEST >
Result< void >	SetImpl (Data &&data, OverloadRank1)

template<typename DEST >
Result< void >	SetImpl (const Data &data, OverloadRank1)

template<typename DEST >
Result< void >	SetImpl (Data &data, OverloadRank1)

template<typename T >
T *	GetPtr ()

template<>
Data *	GetPtr ()

template<typename T >
void	Set (const T &value)

static String	ToString (const T object, const FormatStatement formatStatement, Bool checkDataType)

MAXON_IMPLICIT	DataTypePtr (const DataType &type)

template<>
Result< void >	Get () const

template<>
Result< void >	Set (const Data &value)

template<>
Result< void >	Set (Data &value)

template<>
Result< void >	Set (Data &&value)

Bool	operator== (const ConstDataPtr &other) const

template<>
Result< void >	Get () const

template<>
Result< Data >	Get ()

	operator InternedIdPtr () const

Variables
static constexpr Bool	KEEP

static constexpr Int	InvalidArrayIndex

static constexpr Int	MAXON_FLEXIBLE_ARRAY_LENGTH

const void *	g_zeroMemory

static constexpr Int	ZERO_MEMORY_SIZE

static constexpr const void *const	g_zeroPtr

static constexpr ENUM_DONT_INITIALIZE	DONT_INITIALIZE

static constexpr IN_PLACE_TYPE	IN_PLACE

const ARG &	src

return	OK

template<typename T , GET_DATATYPE_POLICY POLICY, Bool ELEMENTARY>
const DataTypeCache DataTypeCacheInstance< T, POLICY, ELEMENTARY >::_instance &	CheckedGetDataType

struct maxon::TypeArguments	MAXON_ENUM_ORDERED_LIST

static HelperStorage	_helper

Macro Definition Documentation

◆ MAXON_ATTRIBUTE_DLL_PUBLIC

#define MAXON_ATTRIBUTE_DLL_PUBLIC

Use MAXON_ATTRIBUTE_DLL_PUBLIC in the declaration of a variable or function to export symbols (project settings make them private by default), e.g. MAXON_ATTRIBUTE_DLL_PUBLIC int variable; extern "C" MAXON_ATTRIBUTE_DLL_PUBLIC void function();

◆ MAXON_ATTRIBUTE_NO_INLINE

#define MAXON_ATTRIBUTE_NO_INLINE

Use MAXON_ATTRIBUTE_NO_INLINE to prevent the compiler from inlining a method, e.g. static MAXON_ATTRIBUTE_NO_INLINE void FreeContainer(Container& c);

◆ MAXON_ATTRIBUTE_FORCE_INLINE

#define MAXON_ATTRIBUTE_FORCE_INLINE

Use MAXON_ATTRIBUTE_FORCE_INLINE to force the compiler to explicitly inline a method, e.g. MAXON_ATTRIBUTE_FORCE_INLINE Float32 Clamp01(Float32 a)

◆ MAXON_ATTRIBUTE_FORCE_RELEASE_INLINE

#define MAXON_ATTRIBUTE_FORCE_RELEASE_INLINE

See also: MAXON_ATTRIBUTE_FORCE_INLINE. Will do nothing in debug builds, allowing to set breakpoints painlessly.

◆ MAXON_ATTRIBUTE_USED

#define MAXON_ATTRIBUTE_USED

use MAXON_ATTRIBUTE_USED to tell the linker it must not dead-strip a function or static variable (even if it determines that the rest of the program does not refer to the object)

◆ MAXON_HAS_ATTRIBUTE_ALWAYS_CONST

#define MAXON_HAS_ATTRIBUTE_ALWAYS_CONST

◆ MAXON_ATTRIBUTE_ALWAYS_CONST

#define MAXON_ATTRIBUTE_ALWAYS_CONST

◆ MAXON_ATTRIBUTE_ALWAYS_PURE

#define MAXON_ATTRIBUTE_ALWAYS_PURE

◆ PRIVATE_MAXON_DEPRECATED_ENUMVALUE

#define PRIVATE_MAXON_DEPRECATED_ENUMVALUE	(	name,
		value,
		reason
	)

◆ MAXON_DEPRECATED_ENUMVALUE

#define MAXON_DEPRECATED_ENUMVALUE	(	name,
		value,
		reason
	)

Use MAXON_DEPRECATED_ENUMVALUE to mark an enum value being deprecated. This macro is processed by MSVC, Clang, GCC and Doxygen.

Note: Don't use a comma after the macro!

Example:

enum class COLORS
{
  RED,
  GREEN,
  BLUE,
 
  MAXON_DEPRECATED_ENUMVALUE(BROWN, 100, "Color for brown objects. Use red from now on")
  MAXON_DEPRECATED_ENUMVALUE(YELLOW, 200, "Color for yellow objects. Use blue from now on")
};

◆ MAXON_IMPLICIT

#define MAXON_IMPLICIT

Use MAXON_IMPLICIT to mark a constructor which may be used for implicit conversions. Example:

class MyClass
{
public:
  MAXON_IMPLICIT MyClass(Int x);
  explicit MyClass(const Char* x);
};
 
void Func(const MyClass& x);
 
Func(42) // OK: the constructor is used for an implicit conversion of 42 to a temporary MyClass object
Func("Hello World"); // Error: the constructor is marked explicit

Note that you have to mark a potential conversion constructor (i.e., one that takes a single argument) with either MAXON_IMPLICIT or explicit, otherwise the source processor will complain.

◆ MAXON_ATTRIBUTE_SYSCHAR_IS_CHAR

#define MAXON_ATTRIBUTE_SYSCHAR_IS_CHAR

Internal.

◆ MAXON_CONSTEXPR_EVAL

#define MAXON_CONSTEXPR_EVAL	(	T,
		X
	)

Forces a compile-time evaluation of the constexpr expression X of integral type T. Sometimes this is needed to give the compiler a clue that the expression can be evaluated at run-time, which then can enable further optimization.

Parameters

T	Type of the expression (has to be an integral type).
X	The expression.

Returns: Compile-time constant value of the expression.

◆ PRIVATE_MAXON_AS_UTF8

#define PRIVATE_MAXON_AS_UTF8 ( x )

◆ CONSTSTRING

#define CONSTSTRING ( x )

◆ PRIVATE_MAXON_TRANSLATIONUNIT_FLAGS

#define PRIVATE_MAXON_TRANSLATIONUNIT_FLAGS

◆ PRIVATE_MAXON_TRANSLATIONUNIT_FLAGS_2

#define PRIVATE_MAXON_TRANSLATIONUNIT_FLAGS_2

◆ PRIVATE_MAXON_DETECT_MEMBER_HELPER1

#define PRIVATE_MAXON_DETECT_MEMBER_HELPER1	(	x,
		i,
		a
	)

◆ PRIVATE_MAXON_DETECT_MEMBER_HELPER2

#define PRIVATE_MAXON_DETECT_MEMBER_HELPER2	(	x,
		i,
		a
	)

◆ PRIVATE_MAXON_DETECT_MEMBER_HELPER3

#define PRIVATE_MAXON_DETECT_MEMBER_HELPER3	(	x,
		i,
		a
	)

◆ MAXON_DETECT_MEMBER_HELPER

#define MAXON_DETECT_MEMBER_HELPER	(	NAME,
		...
	)

Example usage of this macro is MAXON_DETECT_MEMBER_HELPER(WriteTo, const char*); this allows automatic detection of the WriteTo as a member or static function: struct X { Bool WriteTo(const char* str) const { } }; or struct Y {}; static Bool WriteTo(const Y& y, const char* str) { }

You can add a fallback by using overload rank 0, or further specializations with ranks starting at 3, e.g.,

template <typename T> typename SFINAEHelper<Bool, ... some T-based check...>::type WriteToHelper(OverloadRank3, T& obj, const char* str);

obj

PyObject * obj

Definition: complexobject.h:60

str

void * str

Definition: bytesobject.h:77

Bool

maxon::Bool Bool

Definition: ge_sys_math.h:51

maxon::OverloadRank3

PrivateOverloadRank3 * OverloadRank3

See OverloadRank0.

Definition: apibase.h:673

type

PyObject ** type

Definition: pycore_pyerrors.h:34

◆ MAXON_SCOPE

#define MAXON_SCOPE

Marks a block of code that is scoped for a certain reason.

MAXON_SCOPE // do whatever you want
{
  ScopedLock lock(lock);
  ... more code ...
}

◆ MAXON_WARN_MUTE_FUNCTION_LENGTH

#define MAXON_WARN_MUTE_FUNCTION_LENGTH

Marks a function so that the source processor doesn't issue a warning if the function length exceeds the line count limit. This should really only be used where it doesn't make sense to split up the function into smaller pieces, such as the initialization of tables.

MAXON_WARN_MUTE_FUNCTION_LENGTH Result<void> InitTranslationTable()
{
  ... really long function ...
}

◆ MAXON_WARN_MUTE_NAMING

#define MAXON_WARN_MUTE_NAMING

Marks a declaration so that the source processor doesn't issue a warning if the declaration violates the naming conventions of the style guide.

MAXON_WARN_MUTE_NAMING TIFFErrorHandler _TIFFwarningHandler = nullptr;

MAXON_WARN_MUTE_NAMING

#define MAXON_WARN_MUTE_NAMING

Definition: apibase.h:2911

◆ PRIVATE_MAXON_DATATYPE_A

#define PRIVATE_MAXON_DATATYPE_A	(	type,
		id,
		...
	)

◆ PRIVATE_MAXON_DATATYPE

#define PRIVATE_MAXON_DATATYPE	(	type,
		id,
		...
	)

◆ MAXON_DATATYPE

#define MAXON_DATATYPE	(	type,
		id,
		...
	)

MAXON_DATATYPE declares a primary DataType for the given type. Use this in a header file to be able to use values of type for the DataType system. There has to be a matching DataType definition via MAXON_DATATYPE_REGISTER in a cpp file.

MAXON_DATATYPE(TimeValue, "net.maxon.datatype.timevalue");

MAXON_DATATYPE

#define MAXON_DATATYPE(type, id,...)

Definition: datatype.h:296

You don't have to declare data types for interfaces, this is done automatically. Also you don't have to declare data types for template instantiations if there is a ParametricType for the class template. For example there is a ParametricType for StrongRef<T>, so for any T for which a DataType is declared the DataType for StrongRef<T> needn't be declared because the ParametricType automatically derives it from the DataType for T.

Parameters

[in]	type	Type for which a DataType shall be implemented.
[in]	id	Unique identifier of the data type.
[in]	...	Optional information about the datatype, for now only MAXON_IMPLEMENTATION_MODULE can be used here.

◆ PRIVATE_MAXON_DATATYPE_REGISTER

#define PRIVATE_MAXON_DATATYPE_REGISTER	(	T,
		ret,
		flags
	)

◆ PRIVATE_MAXON_DATATYPE_REGISTER_ENUM

#define PRIVATE_MAXON_DATATYPE_REGISTER_ENUM	(	enumtype,
		cppname,
		id,
		size,
		flags,
		names,
		...
	)

◆ MAXON_DATATYPE_REGISTER

#define MAXON_DATATYPE_REGISTER ( type )

MAXON_DATATYPE_REGISTER defines the implementation of a maxon::DataType for the given type. This macro has to be used in a cpp file, and there has to be a corresponding MAXON_DATATYPE in a header file. For each type, there must be exactly one MAXON_DATATYPE_REGISTER for the whole application. The usage is as easy as

MAXON_DATATYPE_REGISTER(TimeValue);

MAXON_DATATYPE_REGISTER

#define MAXON_DATATYPE_REGISTER(type)

Definition: datatype.h:338

However, this assumes that the appropriate functions for comparison, string conversion etc. are available in the current scope.

If the type is a struct type consisting of public member variables, you can use MAXON_DATATYPE_REGISTER_STRUCT to make the members of your type accessible to the DataType system.

Parameters

[in] type Type for which a DataType shall be implemented.

◆ PRIVATE_MAXON_DATATYPE_LOCAL_STATIC

#define PRIVATE_MAXON_DATATYPE_LOCAL_STATIC

◆ MAXON_DATATYPE_LOCAL

#define MAXON_DATATYPE_LOCAL	(	type,
		id
	)

MAXON_DATATYPE_LOCAL can be used for DataType declarations which need not be publicly visible in a header file. It comprises the declaration (which would normally done by MAXON_DATATYPE in a header file) and its implementation (normally done by MAXON_DATATYPE_REGISTER). MAXON_DATATYPE_LOCAL has to be placed in a cpp file. The functions for comparison, string conversion etc. are taken from the current scope.

Parameters

[in]	type	Type for which a local DataType shall be declared and implemented.
[in]	id	The unique identifier of the local data type.

◆ PRIVATE_MAXON_DATATYPE_REGISTER_STRUCT_INIT

#define PRIVATE_MAXON_DATATYPE_REGISTER_STRUCT_INIT	(	x,
		i,
		a
	)

◆ PRIVATE_MAXON_DATATYPE_REGISTER_STRUCT_OFFSETS

#define PRIVATE_MAXON_DATATYPE_REGISTER_STRUCT_OFFSETS	(	x,
		i,
		a
	)

◆ PRIVATE_MAXON_DATATYPE_REGISTER_STRUCT_B

#define PRIVATE_MAXON_DATATYPE_REGISTER_STRUCT_B	(	Type,
		line,
		count,
		...
	)

◆ PRIVATE_MAXON_DATATYPE_REGISTER_STRUCT_A

#define PRIVATE_MAXON_DATATYPE_REGISTER_STRUCT_A	(	type,
		line,
		count,
		...
	)

◆ MAXON_DATATYPE_REGISTER_STRUCT

#define MAXON_DATATYPE_REGISTER_STRUCT	(	type,
		...
	)

MAXON_DATATYPE_REGISTER_STRUCT defines the implementation of a DataType for the given type, and it also sets up an underlying tuple type which is composed of the members given by ... . You can use this instead of MAXON_DATATYPE_REGISTER for a struct type consisting of public member variables, then the members of your type are accessible to the DataType system. Also there's no need to implement the DescribeIO function because the one from the underlying type is used.

This macro has to be used in a cpp file, and there has to be a corresponding MAXON_DATATYPE in a header file.

// header file
struct Member
{
  DataType type;
  InternedId name;
};
 
MAXON_DATATYPE(Member, "net.maxon.datatype.member");
 
// cpp file
MAXON_DATATYPE_REGISTER_STRUCT(Member, type, name);

Parameters

[in]	type	Type for which a DataType shall be implemented.
[in]	...	List of the names of the member variables of type.

◆ SPLINEMAPPER_KNOT_GET_ID

#define SPLINEMAPPER_KNOT_GET_ID ( flags )

Gets the ID of a SplineMapperKnot. Usage:

Int32 id = SPLINEMAPPER_KNOT_GET_ID(point.flags);

Int32

maxon::Int32 Int32

Definition: ge_sys_math.h:56

SPLINEMAPPER_KNOT_GET_ID

#define SPLINEMAPPER_KNOT_GET_ID(flags)

Definition: splinemapper.h:21

◆ SPLINEMAPPER_KNOT_SET_ID

#define SPLINEMAPPER_KNOT_SET_ID	(	flags,
		flag_id
	)

Sets the ID of a SplineMapperKnot. Usage:

SPLINEMAPPER_KNOT_SET_ID(point.flags, id);

SPLINEMAPPER_KNOT_SET_ID

#define SPLINEMAPPER_KNOT_SET_ID(flags, flag_id)

Definition: splinemapper.h:27

Typedef Documentation

◆ Int16

using Int16 = int16_t

16 bit signed integer datatype.

◆ UInt16

using UInt16 = uint16_t

16 bit unsigned integer datatype.

◆ Int32

using Int32 = int32_t

32 bit signed integer datatype.

◆ UInt32

using UInt32 = uint32_t

32 bit unsigned integer datatype.

◆ Int64

using Int64 = int64_t

64 bit signed integer datatype.

◆ UInt64

using UInt64 = uint64_t

64 bit unsigned integer datatype.

◆ Bool

using Bool = bool

boolean type, possible values are only false/true, 8 bit

◆ Float32

using Float32 = float

32 bit floating point value (float)

◆ Float64

using Float64 = double

64 bit floating point value (double)

◆ Char

using Char = char

signed 8 bit character

◆ UChar

using UChar = unsigned char

unsigned 8 bit character

◆ Int

using Int = Int64

signed 32/64 bit int, size depends on the platform

◆ UInt

using UInt = UInt64

unsigned 32/64 bit int, size depends on the platform

◆ Float

using Float = Float64

current floating point model. right now it's adjusted to Float64==64 bit but maybe it's redefined to Float32 anytime

◆ Byte

using Byte = std::byte

A byte.

◆ Utf32Char

using Utf32Char = char32_t

32 bit unicode (UTF-32) character. Utf32Char is the datatype for a single 32 bit unicode character.

◆ Utf16Char

using Utf16Char = char16_t

16 bit unicode character. Note that complex unicodes can be composed of two individual 16 bit characters.

◆ SysChar

using SysChar = char

System-specific character. This is the character that will be fed to all system functions. Under windows this is a 16-bit wide value, all other platforms define it as 8-bit (and encode strings as UTF-8).

◆ type [1/11]

using type = Char

◆ type [2/11]

using type = Int16

◆ type [3/11]

using type = Int32

◆ type [4/11]

using type = Int64

◆ type [5/11]

using type = UChar

◆ type [6/11]

using type = UInt16

◆ type [7/11]

using type = UInt32

◆ type [8/11]

using type = UInt64

◆ type [9/11]

using type = T

◆ DT

using DT = typename std::decay<T>::type

◆ type [10/11]

using type = typename std::conditional<KEEP, T, typename std::conditional<STD_IS_REPLACEMENT(signed, T), typename IntType<sizeof(T)>::type, typename UIntType<sizeof(T)>::type>::type>::type

◆ HashInt

using HashInt = UInt

HashInt is used as return type of GetHashCode functions. It has the same bit width as Int. With that bit width hash collisions for reasonable hash code functions are rare but possible.

◆ type [11/11]

using type = T

The result type will always be T.

◆ InitMTable

using InitMTable = void (*)()

initSystemTable/InitMTable is not allowed to call thread specific methods as the thread model is not up at the point of calling

◆ DestructorPointer

using DestructorPointer = void (*)(const void*)

◆ BoolLValue

using BoolLValue = DefaultLValue<Bool>

Use this class when you need a default argument for parameters of type Bool&. As an example, consider a function which adds elements to some set:

Result<void> Add(Element* e, Bool& added = BoolLValue());

Add

@ Add

Definition: Python-ast.h:24

maxon::BoolLValue

DefaultLValue< Bool > BoolLValue

Definition: apibase.h:2874

e

Py_ssize_t * e

Definition: longobject.h:89

Element

Definition: annotations.h:7

e could already exist before in the set, so added is set to indicate if e was really added. If you as a caller are not interested in this, the default argument helps to provide a valid temporary lvalue object.

◆ ResultMem

typedef ResultMemT< Bool > ResultMem

Use this class as result type of functions that can fail in out-of-memory situations. This allows to use the result in combination with iferr or Result<void> return values. ResultMem accepts Bool, ResultPtr, ResultRef, pointers and strong/unique references in its constructors.

ResultMem is just a type alias for ResultMemT<Bool>.

Enumeration Type Documentation

◆ ENUM_DONT_INITIALIZE

enum ENUM_DONT_INITIALIZE

strong

Marker type for constructors which don't initialize the class members at all. E.g., vectors usally initialize all components with (0, 0, 0). Vector v(DONT_INITIALIZE); will create an uninitialized vector.

Enumerator
VALUE

◆ IN_PLACE_TYPE

enum IN_PLACE_TYPE

strong

Marker type to resolve ambiguity for perfect-forwarded in-place constructors.

Enumerator
VALUE

◆ CONVERSION_FLAGS

enum CONVERSION_FLAGS

strong

This enum defines flags for a DataType conversion.

See also: AddConversion; Convert

Enumerator
NONE	When no other flags are set, the conversion is a one-to-one correspondence (such as from Float to TimeValue and back).
NARROWING	The conversion contains a narrowing conversion. The conversion may not always be possible (such as converting a negative Int to a UInt), then it returns an error.
WIDENING_LOSSY	The conversion contains a widening conversion which is always possible, but it might result in loss of precision (a Float64 can't represent all bits of an Int64).
WIDENING_LOSSLESS	The conversion contains a lossless widening conversion.
REDUCING	The conversion contains a reducing conversion such as from a vector to a scalar (or a higher-dimensional vector to a lower-dimensional vector).
EXPANDING	The conversion contains an expanding conversion such as from a scalar to a vector (or a lower-dimensional vector to a higher-dimensional vector).
STRUCT_CAST	The conversion contains a cast between layout-compatible structs (such as from Vector to Color).
ITERATION	The conversion contains an iteration over a collection (such as from a Vector-array to Vector).
INCONVERTIBLE	No conversion possible.
WIDENING_MASK	Mask to check for a widening conversion (combination of WIDENING_LOSSY and WIDENING_LOSSLESS).
NARROWING_REDUCING_MASK	Mask to check for a narrowing or reducing conversion (combination of NARROWING and REDUCING).

◆ GET_DATATYPE_POLICY

enum GET_DATATYPE_POLICY

strong

GET_DATATYPE_POLICY controls the behavior of GetDataType for special cases.

Enumerator
NONE
GENERIC_FOR_UNKNOWN	Set this flag if the datatype of Generic shall be returned for a type which hasn't been registered (otherwise a compile-time error happens unless ERROR_FOR_UNKNOWN is set).
ERROR_FOR_UNKNOWN	Set this flag if a runtime error shall be returned by CheckedGetDataType for a type which hasn't been registered (otherwise a compile-time error happens unless GENERIC_FOR_UNKNOWN is set).
RESULT_FOR_UNKNOWN_MASK

◆ DATATYPEMODE

enum DATATYPEMODE

strong

Enumerator
SMALLISPOD
SMALL
BIG

◆ INNERMOST_MEMBER

enum INNERMOST_MEMBER : Int32

strong

◆ COMPARERESULT

enum COMPARERESULT : int

strong

Data type for comparison results.

Enumerator
LESS	result is less than
EQUAL	result is equal
GREATER	result is greater than
INCOMPARABLE	Values are incomparable (either a compare function doesn't exist, or we have a partial order).

◆ EQUALITY

enum EQUALITY

strong

EQUALITY is used for the second parameter of the IsEqual-function of collections. It controls whether the collection shall do the equality check on its values using == or IsEqual.

Enumerator
SHALLOW	A shallow equality-test shall be done. For pointers or (non-copy-on-write) references the object identity (pointer value) is used.
DEEP	A deep equality-test shall be done. For pointers or (non-copy-on-write) references the referenced objects are compared for equality.

Function Documentation

◆ attribute() [1/4]

__attribute__ ( (always_inline) ) const

User-defined literal to allow floating-point constants with the Float datatype of the MAXON API. E.g. instead of writing 1.0 or 1.0f better write 1.0_f to use the Float type.

Aligns value according to alignment. alignment has to be a power of two, then the function returns the smallest value not less than value which is a multiple of alignment.

Parameters

[in]	value	Value to align.
[in]	alignment	Required alignment, must be a power of two.

Returns: Aligned value (multiple of alignment closest to and not less than value).

Aligns value according to alignment. alignment has to be a power of two, then the function returns the smallest pointer value not pointing below value which is a multiple of alignment.

Parameters

[in]	value	Pointer value to align.
[in]	alignment	Required alignment, must be a power of two.

Returns: Aligned pointer value (multiple of alignment closest to and not less than value).

◆ attribute() [2/4]

__attribute__ ( (always_inline) ) const &

Copy assignment.

Returns a C++ reference to an object of type const T whose memory consists of immutable zero bytes. This size of T must not exceed 1024 bytes. This is not checked by the compiler to allow for incomplete types.

Returns a C++ reference to an object of type const T whose memory consists of immutable zero bytes The size of T must not exceed the size of a pointer. This is not checked by the compiler to allow for incomplete types.

◆ StringInterface_GetAndCacheConstString() [1/2]

const String& maxon::StringInterface_GetAndCacheConstString	(	const wchar_t *	str,
		Int	len
	)

Internal. Forwards to StringInterface::GetAndCacheConstString, this allows to use CONSTSTRING and the literal operator _s in uninstantiated template code without having to include string.h

◆ StringInterface_GetAndCacheConstString() [2/2]

const String& maxon::StringInterface_GetAndCacheConstString	(	const Char *	str,
		Int	len,
		Int	isUtf8
	)

Internal. Forwards to StringInterface::GetAndCacheConstString, this allows to use CONSTSTRING and the literal operator _s in uninstantiated template code without having to include string.h

◆ PrivateIsUtf8()

constexpr Bool maxon::PrivateIsUtf8	(	const char *	str,
		Int	len
	)

constexpr

◆ GlobalToString()

String GlobalToString	(	const T &	object,
		const FormatStatement *	formatStatement,
		Bool	checkDataType = `true`
	)

Forwards to ToString function overloads. A call to GlobalToString can be used within a class if the class itself declares a ToString member function (which is quite common): Then this function hides the ToString functions of enclosing namespaces, and to call them you either have to write maxon::ToString (but then you have to be sure that the function is in the maxon namespace), or just GlobalToString (which utilizes argument-dependent lookup and, thus, finds ToString functions in all related namespaces).

Parameters

[in]	object	Some object to be converted to a string.
[in]	formatStatement	Nullptr or additional formatting instruction. See also Formatting Integer values.
[in]	checkDataType	Must be set to true (the default value), only for internal use.

Returns: The converted result.

◆ ~EmptyVirtualClass()

virtual ~EmptyVirtualClass ( )

virtual

◆ MakeDependentExpr()

E&& maxon::MakeDependentExpr ( E && value )

Artificially makes the given expression value dependent on a template type parameter T. This can be used in function templates when an expression contains an incomplete type at its point of definition (so that compilers complain), but the type will be complete when the template is instantiated later.

Template Parameters

T	A template type parameter on which the expression shall be made dependent.

Parameters

[in] value The expression value.

Returns: The forwarded expression value.

◆ addressof()

T* std::maxon_std::addressof ( T & x )

◆ MAXON_ENUM_LIST() [1/4]

enum maxon::ENUM_DONT_INITIALIZE maxon::MAXON_ENUM_LIST ( ENUM_DONT_INITIALIZE )

◆ MAXON_ENUM_LIST() [2/4]

enum maxon::IN_PLACE_TYPE maxon::MAXON_ENUM_LIST ( IN_PLACE_TYPE )

◆ Helper() [1/3]

maxon::Helper	(	OverloadRank2	,
		T &obj	MAXON_MAKE_LISTPRIVATE_MAXON_DETECT_MEMBER_HELPER1,,,,
	)		-> decltype(obj. GetMemorySize (MAXON_MAKE_COMMA_LIST(PRIVATE_MAXON_DETECT_MEMBER_HELPER2,,,)))

◆ Helper() [2/3]

maxon::Helper	(	OverloadRank1	,
		T &obj	MAXON_MAKE_LISTPRIVATE_MAXON_DETECT_MEMBER_HELPER1,,,,
	)		-> decltype( GetMemorySize (obj MAXON_MAKE_LIST(PRIVATE_MAXON_DETECT_MEMBER_HELPER3,,,,)))

◆ Helper() [3/3]

maxon::Helper ( T &obj MAXON_MAKE_LISTPRIVATE_MAXON_DETECT_MEMBER_HELPER1,,,, ) -> decltype(MAXON_CONCAT( GetMemorySize , Helper)( ((maxon::OverloadRankMax) nullptr) , obj MAXON_MAKE_LIST(PRIVATE_MAXON_DETECT_MEMBER_HELPER3,,,,)))

◆ attribute() [3/4]

T& maxon::__attribute__ ( (always_inline) ) &&

UseVariable creates a little bit of code that makes sure that you won't get a warning for an unused variable. or the unused return value of an expression. You can also use this macro to make sure a speed test is not removed by the compiler, otherwise the example would be completely removed by the compiler's optimizer. Please note that UseVariable will create a little bit of extra code, therefore do not use it in speed critical code.

Float sum = 0.0;
for (Int64 i = 0; i < 10000000; i++)
{
  sum += Sin((Float)i);
}
UseVariable(sum);

◆ TestForCopyFromFunction() [1/2]

decltype(std::declval<T>().CopyFrom(std::declval<const T&>())) maxon::TestForCopyFromFunction ( OverloadRank1 )

◆ TestForCopyFromFunction() [2/2]

std::false_type maxon::TestForCopyFromFunction ( OverloadRank0 )

◆ PlacementNew() [1/2]

std::enable_if<!std::is_scalar<T>::value, T*>::type maxon::PlacementNew ( void * ptr )

Default placement new call which does not null the memory (unless it's a scalar type).

Uses new T instead of new T() to avoid unwanted memsets(0) for the memory when there is no user-provided constructor (this includes =default) and the compiler deems something to be uninitialized.

◆ PlacementNew() [2/2]

T* maxon::PlacementNew	(	void *	ptr,
		ARGS &&...	args
	)

Placement new call with forwarded values.

◆ attribute() [4/4]

__attribute__ ( (always_inline) ) &

Calls new (&dst) T(src) or dst.CopyFrom(src) if T has a CopyFrom function.

Converting copy assignment.

◆ Destruct()

void maxon::Destruct ( const T * object )

Destructs the object.

Template Parameters

T	Type of object.

Parameters

[out] object The object to destruct.

◆ GetDestructorPointer()

DestructorPointer maxon::GetDestructorPointer ( )

Returns a function to destruct an object of type T.

Template Parameters

T	Type of object.

◆ Reset()

void maxon::Reset ( T & object )

Resets the object to the state of a default-constructed T. This function destructs obj and then default-constructs a new T in place.

Template Parameters

T	Type of object.

Parameters

[out] object The object to reset.

◆ Create() [1/2]

static auto maxon::Create ( ARGS &&... args )

static

Constructs a new object of type T with the given arguments.

If T has a member function named Init, a default-constructed object will be used, the Init function will be called on that object with the given arguments, and the object will be returned (or a possible error returned by the Init function). The return type is Result<T>.
Otherwise, a constructor of T is called with the given arguments. In this case the return type is ResultOk<T>.
Template Parameters

T Type of object to construct.

Parameters

[in] args Optional arguments for constructor or Init function.

Returns
The constructed object.

◆ MergeDataDictionaries()

Result<void> maxon::MergeDataDictionaries	(	DataDictionary &	base,
		const DataDictionary &	other,
		Bool	mergeSubContainers
	)

MergeDataDictionaries combines the two given data dictionaries into the base dictionary. The same keys in 'other' will overwrite the base values.

Parameters

[in]	base	Dictionary to merge as the base.
[in]	other	Dictionary to merge into base. this values will overwrite values with the same key in 'base'.
[in]	mergeSubContainers	True if sub dictionaries inside the dictionary should be merged recursively as well. False if the dictionary is treated like atomic data.

Returns: OK on success.

◆ MergeDataDictionariesPreferBase()

Result<void> maxon::MergeDataDictionariesPreferBase	(	DataDictionary &	base,
		const DataDictionary &	other,
		Bool	mergeSubContainers
	)

◆ PrivateGetDataDescriptionValue()

Result<Data> maxon::PrivateGetDataDescriptionValue	(	const Id &	databaseScope,
		const InternedId &	attributeData,
		const ConstDataPtr &	keyPtr
	)

PrivateGetDataDescriptionValue returns a data description value from the database.

Parameters

[in]	databaseScope	Database id.
[in]	attributeData	Attribute to query.
[in]	keyPtr	Key to query.

Returns: Data on success.

◆ GetDataDescriptionValue()

static Result<typename IsFidClass<ATTRIBUTETYPE>::type> maxon::GetDataDescriptionValue	(	ATTRIBUTETYPE &&	attribute,
		KEY &&	key
	)

static

Returns the defined description value of any attribute. Example usage:

Int32 min = GetDataDescriptionValue(MACHINEINFO::NUMBEROFPROCESSORS, DESCRIPTION::DATA::BASE::MINVALUE) iferr_return;

Int32 max = GetDataDescriptionValue(MACHINEINFO::NUMBEROFPROCESSORS, DESCRIPTION::DATA::BASE::MAXVALUE) iferr_return;

maxon::GetDataDescriptionValue

static Result< typename IsFidClass< ATTRIBUTETYPE >::type > GetDataDescriptionValue(ATTRIBUTETYPE &&attribute, KEY &&key)

Definition: datadictionary.h:374

max

const char Py_ssize_t const char Py_ssize_t Py_ssize_t max

Definition: modsupport.h:59

min

const char Py_ssize_t const char Py_ssize_t min

Definition: modsupport.h:58

iferr_return

#define iferr_return

Definition: resultbase.h:1524

Parameters

[in]	attribute	Attribute to find.
[in]	key	Value to return, e.g. DESCRIPTION::DATA::BASE::MAXVALUE.

Returns: Requested value on success. The return type will be determined by the data type of ATTRIBUTETYPE.

◆ GetDataDescriptionValue2()

static Opt<TT> maxon::GetDataDescriptionValue2	(	ATTRIBUTETYPE &&	attribute,
		const ConstDataPtr &	key
	)

static

◆ GetDataDescriptionValueFromKey()

static Result<typename IsFidClass<KEY>::type> maxon::GetDataDescriptionValueFromKey	(	ATTRIBUTETYPE &&	attribute,
		KEY &&	key
	)

static

Returns the defined key value description of any attribute. Example usage:

BaseArray<Tuple<Id, Data>> dataTypeList = GetDataDescriptionValueFromKey(DESCRIPTION::DATA::BASE::DATATYPE, DESCRIPTION::DATA::BASE::ENUM) iferr_return;

maxon::GetDataDescriptionValueFromKey

static Result< typename IsFidClass< KEY >::type > GetDataDescriptionValueFromKey(ATTRIBUTETYPE &&attribute, KEY &&key)

Definition: datadictionary.h:407

Parameters

[in]	attribute	Attribute to find.
[in]	key	Value to return, e.g. DESCRIPTION::DATA::BASE::ENUM.

Returns: Requested value on success. The return type will be determined by the data type of KEY.

◆ GetDefaultFromFidIfAvailable() [1/2]

TT maxon::GetDefaultFromFidIfAvailable	(	KEY &&	key,
		OverloadRank0
	)

◆ GetDefaultFromFidIfAvailable() [2/2]

SFINAEHelper<TT, decltype(std::remove_reference<KEY>::type::DEFAULTVALUE)>::type maxon::GetDefaultFromFidIfAvailable	(	KEY &&	key,
		OverloadRank2
	)

◆ GetDefaultValueKey()

ConstDataPtr maxon::GetDefaultValueKey ( )

Returns the Id of DESCRIPTION::DATA::BASE::DEFAULTVALUE.

◆ TransferPropertyIfAvailable()

Result<void> maxon::TransferPropertyIfAvailable	(	const SRCCLASS &	src,
		PROPSRCTYPE &&	srcType,
		DSTCLASS &	dst,
		PROPDSTTYPE &&	dstType
	)

TransferPropertyIfAvailable copies the value of src into dst if available.

Parameters

[in]	src	Source object.
[in]	srcType	Source property type id.
[in]	dst	Destination object.
[in]	dstType	Destination property type id.

Returns: OK on success.

◆ MAXON_DECLARATION() [1/37]

maxon::MAXON_DECLARATION	(	Class< DataDictionaryObjectRef >	,
		DataDictionaryObjectEmptyClass	,
		"net.maxon.class.datadictionaryobjectempty"	,
		MAXON_IMPLEMENTATION_MODULE("net.maxon.kernel")
	)

Implementation of the DataDictionaryObjectInterface without any data stored. This class can be used as a base component for you own inherited classes which overrides SetData/GetData.

◆ MAXON_DECLARATION() [2/37]

maxon::MAXON_DECLARATION	(	Class< DataDictionaryObjectRef >	,
		DataDictionaryObjectClass	,
		"net.maxon.class.datadictionaryobject"	,
		MAXON_IMPLEMENTATION_MODULE("net.maxon.kernel")
	)

Implementation of the DataDictionaryObjectInterface without locking, so it's not threadsafe.

◆ MAXON_DECLARATION() [3/37]

maxon::MAXON_DECLARATION	(	Class< DataDictionaryObjectRef >	,
		DataDictionaryBlockArraySmallObjectClass	,
		"net.maxon.class.datadictionaryblockarraysmallobject"	,
		MAXON_IMPLEMENTATION_MODULE("net.maxon.kernel")
	)

Implementation of the DataDictionaryObjectInterface without locking, so it's not threadsafe. Uses a BlockArrayAllocator to store data faster than DataDictionaryObjectClass Good to use for temporary data/components with 0 to 100 elements.

◆ MAXON_DECLARATION() [4/37]

maxon::MAXON_DECLARATION	(	Class< DataDictionaryObjectRef >	,
		DataDictionaryObjectLockedClass	,
		"net.maxon.class.datadictionaryobjectlocked"	,
		MAXON_IMPLEMENTATION_MODULE("net.maxon.kernel")
	)

Implementation of the DataDictionaryObjectInterface with a spinlock protected hashmap, so it's threadsafe.

◆ MAXON_DECLARATION() [5/37]

maxon::MAXON_DECLARATION	(	Class< DataDictionaryObjectRef >	,
		DataDictionaryObjectSyncedClass	,
		"net.maxon.class.datadictionaryobjectsynced"	,
		MAXON_IMPLEMENTATION_MODULE("net.maxon.kernel")
	)

Implementation of the DataDictionaryObjectInterface with a lockfree hashmap, so it's threadsafe.

◆ MAXON_DECLARATION() [6/37]

maxon::MAXON_DECLARATION	(	Class< DataDictionaryReferenceObjectRef >	,
		DataDictionaryObjectReferenceClass	,
		"net.maxon.class.datadictionaryobjectreference"	,
		MAXON_IMPLEMENTATION_MODULE("net.maxon.kernel")
	)

Implementation of the DataDictionaryObjectInterface with a reference to a DataDictionary. This allows to pass DataDictionary to all functions expecting a DataDictionaryObjectRef.

◆ CreateDataDictionaryReferenceObject() [1/2]

Result<DataDictionaryObjectRef> maxon::CreateDataDictionaryReferenceObject ( DataDictionary * reference )

Creates a DataDictionaryObjectRef for a given DataDictionary pointer. All calls to SetData, GetData, EraseData will be routed to the DataDictionary. So this allows to pass a DataDictionary to all functions which expect a DataDictionaryObjectRef. Important: the DataDictionary object needs to be saved and be valid all the time. Otherwise it will crash.

Parameters

[in] reference Pointer to a DataDictionary.

Returns: DataDictionaryObjectRef which wraps the DataDictionary.

◆ CreateDataDictionaryReferenceObject() [2/2]

Result<DataDictionaryObjectRef> maxon::CreateDataDictionaryReferenceObject ( const DataDictionary * reference )

◆ GetDataDictionaryFromDataDictionaryObjectRef()

Result<DataDictionary> maxon::GetDataDictionaryFromDataDictionaryObjectRef ( const DataDictionaryObjectRef & ref )

Returns a DataDictionary copy the given DataDictionaryObjectRef.

Parameters

[in] ref Reference to a DataDictionaryObjectRef.

Returns: DataDictionary with the copy of all data.

◆ PrivateGetDataType() [1/64]

ResultOk<const DataType&> maxon::PrivateGetDataType	(	GenericArithmetic **	,
		OverloadRank0
	)

◆ PrivateGetDataType() [2/64]

ResultOk<const DataType&> maxon::PrivateGetDataType	(	void **	,
		OverloadRank0
	)

◆ PrivateGetDataType() [3/64]

ResultOk<const DataType&> maxon::PrivateGetDataType	(	std::nullptr_t **	,
		OverloadRank0
	)

◆ PrivateGetDataType() [4/64]

ResultOk<const DataType&> maxon::PrivateGetDataType	(	InvalidType **	,
		OverloadRank0
	)

◆ PrivateGetDataType() [5/64]

SFINAEHelper<Result<const DataType&>, typename T::NonvirtualInterfaceMarker>::type maxon::PrivateGetDataType	(	T **	,
		OverloadRank0
	)

◆ PrivateGetDataType() [6/64]

SFINAEHelper<Result<const DataType&>, typename T::InterfaceMarker>::type maxon::PrivateGetDataType	(	T **	,
		OverloadRank1
	)

◆ PrivateGetDataType() [7/64]

Result<const DataType&> maxon::PrivateGetDataType	(	void *	,
		OverloadRank0
	)

◆ PrivateGetDataType() [8/64]

ResultOk<const DataType&> maxon::PrivateGetDataType	(	DataType **	,
		OverloadRank0
	)

◆ PrivateGetDataType() [9/64]

ResultOk<const DataType&> maxon::PrivateGetDataType	(	DataType::Primary **	,
		OverloadRank0
	)

◆ PrivateGetDataType() [10/64]

ResultOk<const DataType&> maxon::PrivateGetDataType	(	TupleDataType **	,
		OverloadRank0
	)

◆ PrivateDataTypeMarker() [1/32]

void maxon::PrivateDataTypeMarker ( T * )

◆ MAXON_REGISTRY()

maxon::MAXON_REGISTRY	(	DataType	,
		DataTypes	,
		"net.maxon.registry.datatypes"
	)

This registry is used to register all primary data types (those which are declared by MAXON_DATATYPE, and interfaces). It does not include compound data types such as array, tuple or reference types. Use DataType::Get() to obtain a DataType for a data type identifier, whether it is primary or compound.

◆ PrivateDataTypeMarker() [2/32]

void* maxon::PrivateDataTypeMarker ( Char * )

◆ MAXON_DECLARATION() [7/37]

maxon::MAXON_DECLARATION	(	maxon::DataType	,
		DT_Char	,
		"char"	,
		static constexpr maxon::EntityBase::TYPE	TYPE = `maxon::EntityBase::TYPE::DATATYPE;MAXON_IMPLEMENTATION_MODULE("net.maxon.kernel")`
	)

◆ PrivateGetDataType() [11/64]

maxon::ResultOk<const maxon::DataType&> maxon::PrivateGetDataType	(	Char **	,
		maxon::OverloadRank2
	)

◆ MAXON_ASSERT_LEGAL_LAYOUT() [1/31]

maxon::MAXON_ASSERT_LEGAL_LAYOUT ( Char )

◆ PrivateDataTypeMarker() [3/32]

void* maxon::PrivateDataTypeMarker ( UChar * )

◆ MAXON_DECLARATION() [8/37]

maxon::MAXON_DECLARATION	(	maxon::DataType	,
		DT_UChar	,
		"uchar"	,
		static constexpr maxon::EntityBase::TYPE	TYPE = `maxon::EntityBase::TYPE::DATATYPE;MAXON_IMPLEMENTATION_MODULE("net.maxon.kernel")`
	)

◆ PrivateGetDataType() [12/64]

maxon::ResultOk<const maxon::DataType&> maxon::PrivateGetDataType	(	UChar **	,
		maxon::OverloadRank2
	)

◆ MAXON_ASSERT_LEGAL_LAYOUT() [2/31]

maxon::MAXON_ASSERT_LEGAL_LAYOUT ( UChar )

◆ PrivateDataTypeMarker() [4/32]

void* maxon::PrivateDataTypeMarker ( Int16 * )

◆ MAXON_DECLARATION() [9/37]

maxon::MAXON_DECLARATION	(	maxon::DataType	,
		DT_Int16	,
		"int16"	,
		static constexpr maxon::EntityBase::TYPE	TYPE = `maxon::EntityBase::TYPE::DATATYPE;MAXON_IMPLEMENTATION_MODULE("net.maxon.kernel")`
	)

◆ PrivateGetDataType() [13/64]

maxon::ResultOk<const maxon::DataType&> maxon::PrivateGetDataType	(	Int16 **	,
		maxon::OverloadRank2
	)

◆ MAXON_ASSERT_LEGAL_LAYOUT() [3/31]

maxon::MAXON_ASSERT_LEGAL_LAYOUT ( Int16 )

◆ PrivateDataTypeMarker() [5/32]

void* maxon::PrivateDataTypeMarker ( UInt16 * )

◆ MAXON_DECLARATION() [10/37]

maxon::MAXON_DECLARATION	(	maxon::DataType	,
		DT_UInt16	,
		"uint16"	,
		static constexpr maxon::EntityBase::TYPE	TYPE = `maxon::EntityBase::TYPE::DATATYPE;MAXON_IMPLEMENTATION_MODULE("net.maxon.kernel")`
	)

◆ PrivateGetDataType() [14/64]

maxon::ResultOk<const maxon::DataType&> maxon::PrivateGetDataType	(	UInt16 **	,
		maxon::OverloadRank2
	)

◆ MAXON_ASSERT_LEGAL_LAYOUT() [4/31]

maxon::MAXON_ASSERT_LEGAL_LAYOUT ( UInt16 )

◆ PrivateDataTypeMarker() [6/32]

void* maxon::PrivateDataTypeMarker ( Int32 * )

◆ MAXON_DECLARATION() [11/37]

maxon::MAXON_DECLARATION	(	maxon::DataType	,
		DT_Int32	,
		"int32"	,
		static constexpr maxon::EntityBase::TYPE	TYPE = `maxon::EntityBase::TYPE::DATATYPE;MAXON_IMPLEMENTATION_MODULE("net.maxon.kernel")`
	)

◆ PrivateGetDataType() [15/64]

maxon::ResultOk<const maxon::DataType&> maxon::PrivateGetDataType	(	Int32 **	,
		maxon::OverloadRank2
	)

◆ MAXON_ASSERT_LEGAL_LAYOUT() [5/31]

maxon::MAXON_ASSERT_LEGAL_LAYOUT ( Int32 )

◆ PrivateDataTypeMarker() [7/32]

void* maxon::PrivateDataTypeMarker ( UInt32 * )

◆ MAXON_DECLARATION() [12/37]

maxon::MAXON_DECLARATION	(	maxon::DataType	,
		DT_UInt32	,
		"uint32"	,
		static constexpr maxon::EntityBase::TYPE	TYPE = `maxon::EntityBase::TYPE::DATATYPE;MAXON_IMPLEMENTATION_MODULE("net.maxon.kernel")`
	)

◆ PrivateGetDataType() [16/64]

maxon::ResultOk<const maxon::DataType&> maxon::PrivateGetDataType	(	UInt32 **	,
		maxon::OverloadRank2
	)

◆ MAXON_ASSERT_LEGAL_LAYOUT() [6/31]

maxon::MAXON_ASSERT_LEGAL_LAYOUT ( UInt32 )

◆ PrivateDataTypeMarker() [8/32]

void* maxon::PrivateDataTypeMarker ( Int64 * )

◆ MAXON_DECLARATION() [13/37]

maxon::MAXON_DECLARATION	(	maxon::DataType	,
		DT_Int64	,
		"int64"	,
		static constexpr maxon::EntityBase::TYPE	TYPE = `maxon::EntityBase::TYPE::DATATYPE;MAXON_IMPLEMENTATION_MODULE("net.maxon.kernel")`
	)

◆ PrivateGetDataType() [17/64]

maxon::ResultOk<const maxon::DataType&> maxon::PrivateGetDataType	(	Int64 **	,
		maxon::OverloadRank2
	)

◆ MAXON_ASSERT_LEGAL_LAYOUT() [7/31]

maxon::MAXON_ASSERT_LEGAL_LAYOUT ( Int64 )

◆ PrivateDataTypeMarker() [9/32]

void* maxon::PrivateDataTypeMarker ( UInt64 * )

◆ MAXON_DECLARATION() [14/37]

maxon::MAXON_DECLARATION	(	maxon::DataType	,
		DT_UInt64	,
		"uint64"	,
		static constexpr maxon::EntityBase::TYPE	TYPE = `maxon::EntityBase::TYPE::DATATYPE;MAXON_IMPLEMENTATION_MODULE("net.maxon.kernel")`
	)

◆ PrivateGetDataType() [18/64]

maxon::ResultOk<const maxon::DataType&> maxon::PrivateGetDataType	(	UInt64 **	,
		maxon::OverloadRank2
	)

◆ MAXON_ASSERT_LEGAL_LAYOUT() [8/31]

maxon::MAXON_ASSERT_LEGAL_LAYOUT ( UInt64 )

◆ PrivateDataTypeMarker() [10/32]

void* maxon::PrivateDataTypeMarker ( Utf16Char * )

◆ MAXON_DECLARATION() [15/37]

maxon::MAXON_DECLARATION	(	maxon::DataType	,
		DT_Utf16Char	,
		"utf16char"	,
		static constexpr maxon::EntityBase::TYPE	TYPE = `maxon::EntityBase::TYPE::DATATYPE;MAXON_IMPLEMENTATION_MODULE("net.maxon.kernel")`
	)

◆ PrivateGetDataType() [19/64]

maxon::ResultOk<const maxon::DataType&> maxon::PrivateGetDataType	(	Utf16Char **	,
		maxon::OverloadRank2
	)

◆ MAXON_ASSERT_LEGAL_LAYOUT() [9/31]

maxon::MAXON_ASSERT_LEGAL_LAYOUT ( Utf16Char )

◆ PrivateDataTypeMarker() [11/32]

void* maxon::PrivateDataTypeMarker ( Utf32Char * )

◆ MAXON_DECLARATION() [16/37]

maxon::MAXON_DECLARATION	(	maxon::DataType	,
		DT_Utf32Char	,
		"utf32char"	,
		static constexpr maxon::EntityBase::TYPE	TYPE = `maxon::EntityBase::TYPE::DATATYPE;MAXON_IMPLEMENTATION_MODULE("net.maxon.kernel")`
	)

◆ PrivateGetDataType() [20/64]

maxon::ResultOk<const maxon::DataType&> maxon::PrivateGetDataType	(	Utf32Char **	,
		maxon::OverloadRank2
	)

◆ MAXON_ASSERT_LEGAL_LAYOUT() [10/31]

maxon::MAXON_ASSERT_LEGAL_LAYOUT ( Utf32Char )

◆ PrivateDataTypeMarker() [12/32]

void* maxon::PrivateDataTypeMarker ( Float32 * )

◆ MAXON_DECLARATION() [17/37]

maxon::MAXON_DECLARATION	(	maxon::DataType	,
		DT_Float32	,
		"float32"	,
		static constexpr maxon::EntityBase::TYPE	TYPE = `maxon::EntityBase::TYPE::DATATYPE;MAXON_IMPLEMENTATION_MODULE("net.maxon.kernel")`
	)

◆ PrivateGetDataType() [21/64]

maxon::ResultOk<const maxon::DataType&> maxon::PrivateGetDataType	(	Float32 **	,
		maxon::OverloadRank2
	)

◆ MAXON_ASSERT_LEGAL_LAYOUT() [11/31]

maxon::MAXON_ASSERT_LEGAL_LAYOUT ( Float32 )

◆ PrivateDataTypeMarker() [13/32]

void* maxon::PrivateDataTypeMarker ( Float64 * )

◆ MAXON_DECLARATION() [18/37]

maxon::MAXON_DECLARATION	(	maxon::DataType	,
		DT_Float64	,
		"float64"	,
		static constexpr maxon::EntityBase::TYPE	TYPE = `maxon::EntityBase::TYPE::DATATYPE;MAXON_IMPLEMENTATION_MODULE("net.maxon.kernel")`
	)

◆ PrivateGetDataType() [22/64]

maxon::ResultOk<const maxon::DataType&> maxon::PrivateGetDataType	(	Float64 **	,
		maxon::OverloadRank2
	)

◆ MAXON_ASSERT_LEGAL_LAYOUT() [12/31]

maxon::MAXON_ASSERT_LEGAL_LAYOUT ( Float64 )

◆ PrivateDataTypeMarker() [14/32]

void* maxon::PrivateDataTypeMarker ( Bool * )

◆ MAXON_DECLARATION() [19/37]

maxon::MAXON_DECLARATION	(	maxon::DataType	,
		DT_Bool	,
		"bool"	,
		static constexpr maxon::EntityBase::TYPE	TYPE = `maxon::EntityBase::TYPE::DATATYPE;MAXON_IMPLEMENTATION_MODULE("net.maxon.kernel")`
	)

◆ PrivateGetDataType() [23/64]

maxon::ResultOk<const maxon::DataType&> maxon::PrivateGetDataType	(	Bool **	,
		maxon::OverloadRank2
	)

◆ MAXON_ASSERT_LEGAL_LAYOUT() [13/31]

maxon::MAXON_ASSERT_LEGAL_LAYOUT ( Bool )

◆ PrivateDataTypeMarker() [15/32]

void* maxon::PrivateDataTypeMarker ( Byte * )

◆ MAXON_DECLARATION() [20/37]

maxon::MAXON_DECLARATION	(	maxon::DataType	,
		DT_Byte	,
		"byte"	,
		static constexpr maxon::EntityBase::TYPE	TYPE = `maxon::EntityBase::TYPE::DATATYPE;MAXON_IMPLEMENTATION_MODULE("net.maxon.kernel")`
	)

◆ PrivateGetDataType() [24/64]

maxon::ResultOk<const maxon::DataType&> maxon::PrivateGetDataType	(	Byte **	,
		maxon::OverloadRank2
	)

◆ MAXON_ASSERT_LEGAL_LAYOUT() [14/31]

maxon::MAXON_ASSERT_LEGAL_LAYOUT ( Byte )

◆ PrivateDataTypeMarker() [16/32]

void* maxon::PrivateDataTypeMarker ( AInt * )

◆ MAXON_DECLARATION() [21/37]

maxon::MAXON_DECLARATION	(	maxon::DataType	,
		DT_AInt	,
		"int"	,
		static constexpr maxon::EntityBase::TYPE	TYPE = `maxon::EntityBase::TYPE::DATATYPE;MAXON_IMPLEMENTATION_MODULE("net.maxon.kernel")`
	)

◆ PrivateGetDataType() [25/64]

maxon::ResultOk<const maxon::DataType&> maxon::PrivateGetDataType	(	AInt **	,
		maxon::OverloadRank2
	)

◆ MAXON_ASSERT_LEGAL_LAYOUT() [15/31]

maxon::MAXON_ASSERT_LEGAL_LAYOUT ( AInt )

◆ PrivateDataTypeMarker() [17/32]

void* maxon::PrivateDataTypeMarker ( AUInt * )

◆ MAXON_DECLARATION() [22/37]

maxon::MAXON_DECLARATION	(	maxon::DataType	,
		DT_AUInt	,
		"uint"	,
		static constexpr maxon::EntityBase::TYPE	TYPE = `maxon::EntityBase::TYPE::DATATYPE;MAXON_IMPLEMENTATION_MODULE("net.maxon.kernel")`
	)

◆ PrivateGetDataType() [26/64]

maxon::ResultOk<const maxon::DataType&> maxon::PrivateGetDataType	(	AUInt **	,
		maxon::OverloadRank2
	)

◆ MAXON_ASSERT_LEGAL_LAYOUT() [16/31]

maxon::MAXON_ASSERT_LEGAL_LAYOUT ( AUInt )

◆ PrivateDataTypeMarker() [18/32]

void* maxon::PrivateDataTypeMarker ( AFloat * )

◆ MAXON_DECLARATION() [23/37]

maxon::MAXON_DECLARATION	(	maxon::DataType	,
		DT_AFloat	,
		"float"	,
		static constexpr maxon::EntityBase::TYPE	TYPE = `maxon::EntityBase::TYPE::DATATYPE;MAXON_IMPLEMENTATION_MODULE("net.maxon.kernel")`
	)

◆ PrivateGetDataType() [27/64]

maxon::ResultOk<const maxon::DataType&> maxon::PrivateGetDataType	(	AFloat **	,
		maxon::OverloadRank2
	)

◆ MAXON_ASSERT_LEGAL_LAYOUT() [17/31]

maxon::MAXON_ASSERT_LEGAL_LAYOUT ( AFloat )

◆ PrivateDataTypeMarker() [19/32]

void* maxon::PrivateDataTypeMarker ( UniqueHash * )

◆ MAXON_DECLARATION() [24/37]

maxon::MAXON_DECLARATION	(	maxon::DataType	,
		DT_UniqueHash	,
		"net.maxon.datatype.hash"	,
		static constexpr maxon::EntityBase::TYPE	TYPE = `maxon::EntityBase::TYPE::DATATYPE;MAXON_IMPLEMENTATION_MODULE("net.maxon.kernel")`
	)

◆ PrivateGetDataType() [28/64]

maxon::ResultOk<const maxon::DataType&> maxon::PrivateGetDataType	(	UniqueHash **	,
		maxon::OverloadRank2
	)

◆ MAXON_ASSERT_LEGAL_LAYOUT() [18/31]

maxon::MAXON_ASSERT_LEGAL_LAYOUT ( UniqueHash )

◆ PrivateDataTypeMarker() [20/32]

void* maxon::PrivateDataTypeMarker ( Id * )

◆ MAXON_DECLARATION() [25/37]

maxon::MAXON_DECLARATION	(	maxon::DataType	,
		DT_Id	,
		"net.maxon.datatype.id"	,
		static constexpr maxon::EntityBase::TYPE	TYPE = `maxon::EntityBase::TYPE::DATATYPE;MAXON_IMPLEMENTATION_MODULE("net.maxon.kernel")`
	)

◆ PrivateGetDataType() [29/64]

maxon::ResultOk<const maxon::DataType&> maxon::PrivateGetDataType	(	Id **	,
		maxon::OverloadRank2
	)

◆ MAXON_ASSERT_LEGAL_LAYOUT() [19/31]

maxon::MAXON_ASSERT_LEGAL_LAYOUT ( Id )

◆ PrivateDataTypeMarker() [21/32]

void* maxon::PrivateDataTypeMarker ( LiteralId * )

◆ MAXON_DECLARATION() [26/37]

maxon::MAXON_DECLARATION	(	maxon::DataType	,
		DT_LiteralId	,
		"net.maxon.datatype.literalid"	,
		static constexpr maxon::EntityBase::TYPE	TYPE = `maxon::EntityBase::TYPE::DATATYPE;MAXON_IMPLEMENTATION_MODULE("net.maxon.kernel")`
	)

◆ PrivateGetDataType() [30/64]

maxon::ResultOk<const maxon::DataType&> maxon::PrivateGetDataType	(	LiteralId **	,
		maxon::OverloadRank2
	)

◆ MAXON_ASSERT_LEGAL_LAYOUT() [20/31]

maxon::MAXON_ASSERT_LEGAL_LAYOUT ( LiteralId )

◆ PrivateDataTypeMarker() [22/32]

void* maxon::PrivateDataTypeMarker ( InternedId * )

◆ MAXON_DECLARATION() [27/37]

maxon::MAXON_DECLARATION	(	maxon::DataType	,
		DT_InternedId	,
		"net.maxon.datatype.internedid"	,
		static constexpr maxon::EntityBase::TYPE	TYPE = `maxon::EntityBase::TYPE::DATATYPE;MAXON_IMPLEMENTATION_MODULE("net.maxon.kernel")`
	)

◆ PrivateGetDataType() [31/64]

maxon::ResultOk<const maxon::DataType&> maxon::PrivateGetDataType	(	InternedId **	,
		maxon::OverloadRank2
	)

◆ MAXON_ASSERT_LEGAL_LAYOUT() [21/31]

maxon::MAXON_ASSERT_LEGAL_LAYOUT ( InternedId )

◆ PrivateDataTypeMarker() [23/32]

void* maxon::PrivateDataTypeMarker ( Data * )

◆ MAXON_DECLARATION() [28/37]

maxon::MAXON_DECLARATION	(	maxon::DataType	,
		DT_Data	,
		"net.maxon.datatype.data"	,
		static constexpr maxon::EntityBase::TYPE	TYPE = `maxon::EntityBase::TYPE::DATATYPE;MAXON_IMPLEMENTATION_MODULE("net.maxon.kernel")`
	)

◆ PrivateGetDataType() [32/64]

maxon::ResultOk<const maxon::DataType&> maxon::PrivateGetDataType	(	Data **	,
		maxon::OverloadRank2
	)

◆ MAXON_ASSERT_LEGAL_LAYOUT() [22/31]

maxon::MAXON_ASSERT_LEGAL_LAYOUT ( Data )

◆ PrivateDataTypeMarker() [24/32]

void* maxon::PrivateDataTypeMarker ( UnitType * )

◆ MAXON_DECLARATION() [29/37]

maxon::MAXON_DECLARATION	(	maxon::DataType	,
		DT_UnitType	,
		"net.maxon.datatype.unittype"	,
		static constexpr maxon::EntityBase::TYPE	TYPE = `maxon::EntityBase::TYPE::DATATYPE;MAXON_IMPLEMENTATION_MODULE("net.maxon.kernel")`
	)

◆ PrivateGetDataType() [33/64]

maxon::ResultOk<const maxon::DataType&> maxon::PrivateGetDataType	(	UnitType **	,
		maxon::OverloadRank2
	)

◆ MAXON_ASSERT_LEGAL_LAYOUT() [23/31]

maxon::MAXON_ASSERT_LEGAL_LAYOUT ( UnitType )

◆ PrivateDataTypeMarker() [25/32]

void* maxon::PrivateDataTypeMarker ( SourceLocation * )

◆ MAXON_DECLARATION() [30/37]

maxon::MAXON_DECLARATION	(	maxon::DataType	,
		DT_SourceLocation	,
		"net.maxon.datatype.sourcelocation"	,
		static constexpr maxon::EntityBase::TYPE	TYPE = `maxon::EntityBase::TYPE::DATATYPE;MAXON_IMPLEMENTATION_MODULE("net.maxon.kernel")`
	)

◆ PrivateGetDataType() [34/64]

maxon::ResultOk<const maxon::DataType&> maxon::PrivateGetDataType	(	SourceLocation **	,
		maxon::OverloadRank2
	)

◆ MAXON_ASSERT_LEGAL_LAYOUT() [24/31]

maxon::MAXON_ASSERT_LEGAL_LAYOUT ( SourceLocation )

◆ PrivateDataTypeMarker() [26/32]

void* maxon::PrivateDataTypeMarker ( DelegateBase * )

◆ MAXON_DECLARATION() [31/37]

maxon::MAXON_DECLARATION	(	maxon::DataType	,
		DT_DelegateBase	,
		"net.maxon.datatype.delegatebase"	,
		static constexpr maxon::EntityBase::TYPE	TYPE = `maxon::EntityBase::TYPE::DATATYPE;MAXON_IMPLEMENTATION_MODULE("net.maxon.kernel")`
	)

◆ PrivateGetDataType() [35/64]

maxon::ResultOk<const maxon::DataType&> maxon::PrivateGetDataType	(	DelegateBase **	,
		maxon::OverloadRank2
	)

◆ MAXON_ASSERT_LEGAL_LAYOUT() [25/31]

maxon::MAXON_ASSERT_LEGAL_LAYOUT ( DelegateBase )

◆ PrivateGetEnumDataType()

ResultOk<const DataType&> maxon::PrivateGetEnumDataType	(	T *	,
		OverloadRank0
	)

◆ PrivateGetDataType() [36/64]

ResultOk<const DataType&> maxon::PrivateGetDataType	(	long **	,
		OverloadRank0
	)

◆ PrivateGetDataType() [37/64]

ResultOk<const DataType&> maxon::PrivateGetDataType	(	unsigned long **	,
		OverloadRank0
	)

◆ PrivateGetDataType() [38/64]

ResultOk<const DataType&> maxon::PrivateGetDataType	(	ParametricType **	,
		OverloadRank0
	)

◆ PrivateGetDataType() [39/64]

ResultOk<const DataType&> maxon::PrivateGetDataType	(	ComponentDescriptor **	,
		OverloadRank0
	)

◆ PrivateGetDataType() [40/64]

Result<DataType> maxon::PrivateGetDataType	(	T ***	,
		OverloadRank0
	)

◆ PrivateGetDataType() [41/64]

Result<DataType> maxon::PrivateGetDataType	(	Block< T > **	,
		OverloadRank0
	)

◆ PrivateGetDataType() [42/64]

Result<DataType> maxon::PrivateGetDataType	(	StridedBlock< T > **	,
		OverloadRank0
	)

◆ PrivateGetDataType() [43/64]

Result<DataType> maxon::PrivateGetDataType	(	Opt< T > **	,
		OverloadRank0
	)

◆ PrivateGetDataType() [44/64]

Result<DataType> maxon::PrivateGetDataType	(	Result< T > **	,
		OverloadRank0
	)

◆ PrivateGetDataType() [45/64]

Result<DataType> maxon::PrivateGetDataType	(	AtomicBool **	,
		OverloadRank0
	)

◆ PrivateGetDataType() [46/64]

Result<DataType> maxon::PrivateGetDataType	(	Atomic8< T > **	,
		OverloadRank0
	)

◆ PrivateGetDataType() [47/64]

Result<DataType> maxon::PrivateGetDataType	(	Atomic16< T > **	,
		OverloadRank0
	)

◆ PrivateGetDataType() [48/64]

Result<DataType> maxon::PrivateGetDataType	(	Atomic32< T > **	,
		OverloadRank0
	)

◆ PrivateGetDataType() [49/64]

Result<DataType> maxon::PrivateGetDataType	(	Atomic64< T > **	,
		OverloadRank0
	)

◆ PrivateGetDataType() [50/64]

Result<DataType> maxon::PrivateGetDataType	(	AtomicPtr< T > **	,
		OverloadRank0
	)

◆ PrivateGetDataType() [51/64]

Result<DataType> maxon::PrivateGetDataType	(	AtomicFloatType< T > **	,
		OverloadRank0
	)

◆ PrivateGetDataType() [52/64]

Result<DataType> maxon::PrivateGetDataType	(	BaseArray< T > **	,
		OverloadRank0
	)

◆ PrivateGetDataType() [53/64]

Result<TupleDataType> maxon::PrivateGetDataType	(	Tuple< T... > **	,
		OverloadRank0
	)

◆ PrivateGetDataType() [54/64]

Result<TupleDataType> maxon::PrivateGetDataType	(	T **	,
		OverloadRank0
	)

◆ PrivateGetDataType() [55/64]

Result<DelegateDataType> maxon::PrivateGetDataType	(	Delegate< R(ARGS...)> **	,
		OverloadRank2
	)

◆ GetDataType()

const auto & GetDataType ( )

Returns the DataType representation of T. This covers not only primary datatypes which have been registered directly with MAXON_DATATYPE_REGISTER, but also compound types which are derived from other types (such as arrays, pointers, references, tuples).

Template Parameters

T	Type for which the DataType shall be obtained.
POLICY	An optional policy for the operation.

Returns: The DataType representation for T.

Returns the DataType for the given C++ type.

const DataType& type = GetDataType<T>();

const DataType& type = GetDataType<Tuple<Int, String>>();

Template Parameters

T	Type of which the DataType representation shall be obtained.
POLICY	Optional parameter to modify the data type resolution.

Returns: DataType for T.

◆ PrivateGetDataType() [56/64]

ResultOk<const DataType&> maxon::PrivateGetDataType	(	Generic **	,
		OverloadRank0
	)

◆ PrivateDataTypeMarker() [27/32]

void* maxon::PrivateDataTypeMarker ( ConstDataPtr * )

◆ MAXON_DECLARATION() [32/37]

maxon::MAXON_DECLARATION	(	maxon::DataType	,
		DT_ConstDataPtr	,
		"net.maxon.datatype.constdataptr"	,
		static constexpr maxon::EntityBase::TYPE	TYPE = `maxon::EntityBase::TYPE::DATATYPE;MAXON_IMPLEMENTATION_MODULE("net.maxon.kernel")`
	)

◆ PrivateGetDataType() [57/64]

maxon::ResultOk<const maxon::DataType&> maxon::PrivateGetDataType	(	ConstDataPtr **	,
		maxon::OverloadRank2
	)

◆ MAXON_ASSERT_LEGAL_LAYOUT() [26/31]

maxon::MAXON_ASSERT_LEGAL_LAYOUT ( ConstDataPtr )

◆ PrivateDataTypeMarker() [28/32]

void* maxon::PrivateDataTypeMarker ( TrivialDataPtr * )

◆ MAXON_DECLARATION() [33/37]

maxon::MAXON_DECLARATION	(	maxon::DataType	,
		DT_TrivialDataPtr	,
		"net.maxon.datatype.trivialdataptr"	,
		static constexpr maxon::EntityBase::TYPE	TYPE = `maxon::EntityBase::TYPE::DATATYPE;MAXON_IMPLEMENTATION_MODULE("net.maxon.kernel")`
	)

◆ PrivateGetDataType() [58/64]

maxon::ResultOk<const maxon::DataType&> maxon::PrivateGetDataType	(	TrivialDataPtr **	,
		maxon::OverloadRank2
	)

◆ MAXON_ASSERT_LEGAL_LAYOUT() [27/31]

maxon::MAXON_ASSERT_LEGAL_LAYOUT ( TrivialDataPtr )

◆ PrivateDataTypeMarker() [29/32]

void* maxon::PrivateDataTypeMarker ( DataPtr * )

◆ MAXON_DECLARATION() [34/37]

maxon::MAXON_DECLARATION	(	maxon::DataType	,
		DT_DataPtr	,
		"net.maxon.datatype.dataptr"	,
		static constexpr maxon::EntityBase::TYPE	TYPE = `maxon::EntityBase::TYPE::DATATYPE;MAXON_IMPLEMENTATION_MODULE("net.maxon.kernel")`
	)

◆ PrivateGetDataType() [59/64]

maxon::ResultOk<const maxon::DataType&> maxon::PrivateGetDataType	(	DataPtr **	,
		maxon::OverloadRank2
	)

◆ MAXON_ASSERT_LEGAL_LAYOUT() [28/31]

maxon::MAXON_ASSERT_LEGAL_LAYOUT ( DataPtr )

◆ PrivateDataTypeMarker() [30/32]

void* maxon::PrivateDataTypeMarker ( MoveDataPtr * )

◆ MAXON_DECLARATION() [35/37]

maxon::MAXON_DECLARATION	(	maxon::DataType	,
		DT_MoveDataPtr	,
		"net.maxon.datatype.movedataptr"	,
		static constexpr maxon::EntityBase::TYPE	TYPE = `maxon::EntityBase::TYPE::DATATYPE;MAXON_IMPLEMENTATION_MODULE("net.maxon.kernel")`
	)

◆ PrivateGetDataType() [60/64]

maxon::ResultOk<const maxon::DataType&> maxon::PrivateGetDataType	(	MoveDataPtr **	,
		maxon::OverloadRank2
	)

◆ MAXON_ASSERT_LEGAL_LAYOUT() [29/31]

maxon::MAXON_ASSERT_LEGAL_LAYOUT ( MoveDataPtr )

◆ PrivateDataTypeMarker() [31/32]

void* maxon::PrivateDataTypeMarker ( ForwardingDataPtr * )

◆ MAXON_DECLARATION() [36/37]

maxon::MAXON_DECLARATION	(	maxon::DataType	,
		DT_ForwardingDataPtr	,
		"net.maxon.datatype.forwardingdataptr"	,
		static constexpr maxon::EntityBase::TYPE	TYPE = `maxon::EntityBase::TYPE::DATATYPE;MAXON_IMPLEMENTATION_MODULE("net.maxon.kernel")`
	)

◆ PrivateGetDataType() [61/64]

maxon::ResultOk<const maxon::DataType&> maxon::PrivateGetDataType	(	ForwardingDataPtr **	,
		maxon::OverloadRank2
	)

◆ MAXON_ASSERT_LEGAL_LAYOUT() [30/31]

maxon::MAXON_ASSERT_LEGAL_LAYOUT ( ForwardingDataPtr )

◆ PrivateDataTypeMarker() [32/32]

void* maxon::PrivateDataTypeMarker ( Member * )

◆ MAXON_DECLARATION() [37/37]

maxon::MAXON_DECLARATION	(	maxon::DataType	,
		DT_Member	,
		"net.maxon.datatype.member"	,
		static constexpr maxon::EntityBase::TYPE	TYPE = `maxon::EntityBase::TYPE::DATATYPE;MAXON_IMPLEMENTATION_MODULE("net.maxon.kernel")`
	)

◆ PrivateGetDataType() [62/64]

maxon::ResultOk<const maxon::DataType&> maxon::PrivateGetDataType	(	Member **	,
		maxon::OverloadRank2
	)

◆ MAXON_ASSERT_LEGAL_LAYOUT() [31/31]

maxon::MAXON_ASSERT_LEGAL_LAYOUT ( Member )

◆ PrivateGetDataType() [63/64]

Result<TupleDataType> maxon::PrivateGetDataType	(	NamedTuple< T... > **	,
		OverloadRank0
	)

◆ PrivateGetDataType() [64/64]

Result<DataType> maxon::PrivateGetDataType	(	std::integral_constant< T, C > **	,
		OverloadRank0
	)

◆ MAXON_ENUM_FLAGS() [1/2]

enum maxon::CONVERSION_FLAGS maxon::MAXON_ENUM_FLAGS ( CONVERSION_FLAGS )

◆ MAXON_ENUM_FLAGS() [2/2]

enum maxon::GET_DATATYPE_POLICY maxon::MAXON_ENUM_FLAGS ( GET_DATATYPE_POLICY )

◆ operator==() [1/3]

Bool maxon::operator==	(	const ForwardingDataPtr &	a,
		const Data &	b
	)

◆ operator!=()

Bool maxon::operator!=	(	const ForwardingDataPtr &	a,
		const Data &	b
	)

◆ MAXON_DETECT_MEMBER_HELPER()

maxon::MAXON_DETECT_MEMBER_HELPER	(	DescribeIO	,
		const DataSerializeInterface &
	)

◆ DescribeIO()

Result<void> maxon::DescribeIO	(	const T &	s,
		const DataSerializeInterface &	dsi
	)

◆ MAXON_ENUM_LIST() [3/4]

enum maxon::DATATYPEMODE maxon::MAXON_ENUM_LIST ( DATATYPEMODE )

◆ DecltypeNewInstanceHelper()

Result<void*> maxon::DecltypeNewInstanceHelper ( const void * )

◆ PrivateNewInterfaceInstance() [1/2]

static Result<void*> maxon::PrivateNewInterfaceInstance ( OverloadRank0 )

static

◆ PrivateNewInterfaceInstance() [2/2]

static decltype(DecltypeNewInstanceHelper(T::Alloc(maxon::SourceLocation()))) MAXON_WARN_UNUSED maxon::PrivateNewInterfaceInstance ( OverloadRank1 )

static

◆ MAXON_ENUM_ORDERED_LIST() [1/2]

enum maxon::INNERMOST_MEMBER Int32 maxon::MAXON_ENUM_ORDERED_LIST ( INNERMOST_MEMBER )

◆ MAXON_ENUM_ORDERED_LIST() [2/2]

enum maxon::COMPARERESULT int maxon::MAXON_ENUM_ORDERED_LIST	(	COMPARERESULT	,
		"net.maxon.datatype.enum.compareresult"	,
		EARLY
	)

◆ operator==() [2/3]

Bool maxon::operator==	(	COMPARERESULT	a,
		int	b
	)

◆ operator<()

Bool maxon::operator<	(	COMPARERESULT	a,
		int	b
	)

◆ MAXON_ENUM_LIST() [4/4]

enum maxon::EQUALITY maxon::MAXON_ENUM_LIST	(	EQUALITY	,
		"net.maxon.datatype.enum.equality"	,
		EARLY
	)

◆ LexicographicalGreaterThan() [1/2]

Bool maxon::LexicographicalGreaterThan ( )

◆ LexicographicalGreaterThan() [2/2]

Bool maxon::LexicographicalGreaterThan	(	const T1 &	a1,
		const T1 &	b1,
		const TN &...	ab
	)

Lexicographically compares the tuple (a1, a2, ...) against (b1, b2, ...). (a1, a2) is greater than (b1, b2) if a1 > b1, or if a1 == b1 and a2 > b2 (and so forth for the remaining tuple elements). In other words, the first pair ai, bi which is not equal determines the relationship between the tuples.

Parameters

[in]	a1	First value of first tuple.
[in]	b1	First value of second tuple.
[in]	ab	The remaining values of the tuples (in the order a2, b2, a3, b3, ...).

Returns: True if (a1, a2, ...) is lexicographically greater than (b1, b2, ...).

◆ LexicographicalLessThan() [1/2]

Bool maxon::LexicographicalLessThan ( )

◆ LexicographicalLessThan() [2/2]

Bool maxon::LexicographicalLessThan	(	const T1 &	a1,
		const T1 &	b1,
		const TN &...	ab
	)

Lexicographically compares the tuple (a1, a2, ...) against (b1, b2, ...). (a1, a2) is less than (b1, b2) if a1 < b1, or if a1 == b1 and a2 < b2 (and so forth for the remaining tuple elements). In other words, the first pair ai, bi which is not equal determines the relationship between the tuples.

Parameters

[in]	a1	First value of first tuple.
[in]	b1	First value of second tuple.
[in]	ab	The remaining values of the tuples (in the order a2, b2, a3, b3, ...).

Returns: True if (a1, a2, ...) is lexicographically less than (b1, b2, ...).

◆ LexicographicalCompare() [1/2]

COMPARERESULT maxon::LexicographicalCompare ( )

◆ LexicographicalCompare() [2/2]

COMPARERESULT maxon::LexicographicalCompare	(	const T1 &	a1,
		const T1 &	b1,
		const TN &...	ab
	)

Lexicographically compares the tuple (a1, a2, ...) against (b1, b2, ...). For the lexicographic order, (a1, a2) is greater than (b1, b2) if a1 > b1, or if a1 == b1 and a2 > b2 (and so forth for the remaining tuple elements). If all values are equal, the tuples are equal, in the remaining cases (a1, a2) is less than (b1, b2). In other words, the first pair ai, bi which is not equal determines the relationship between the tuples.

Parameters

[in]	a1	First value of first tuple.
[in]	b1	First value of second tuple.
[in]	ab	The remaining values of the tuples (in the order a2, b2, a3, b3, ...).

Returns: Lexicographic comparison of the tuples (a1, a2, ...), (b1, b2, ...).

◆ MAXON_DATATYPE() [1/2]

maxon::MAXON_DATATYPE	(	GradientKnot	,
		"net.maxon.datatype.gradientknot"
	)

◆ Compare()

COMPARERESULT maxon::Compare	(	const GradientKnot &	a,
		const GradientKnot &	b
	)

◆ MAXON_DATATYPE() [2/2]

maxon::MAXON_DATATYPE	(	SplineMapperKnot	,
		"net.maxon.datatype.splinemapperknot"
	)

◆ DataDictionaryIterator() [1/2]

DataDictionaryIterator	(	const DataDictionaryInterface *	dict,
		Bool	end
	)

◆ GetOrDefault() [1/2]

std::conditional<std::is_void<T>::value, typename IsFidClass<KEY>::type, T>::type GetOrDefault ( KEY && key ) const

◆ DataDictionaryIterator() [2/2]

DataDictionaryIterator	(	const DataDictionaryObjectInterface *	dict,
		Bool	end
	)

◆ GetOrDefault() [2/2]

std::conditional<std::is_void<T>::value, typename IsFidClass<KEY>::type, T>::type GetOrDefault ( KEY && key ) const

◆ AssertType()

void AssertType

In debug configuration, checks if this type is the same as #T and writes warnings to the console if not. This functions does nothing in release configuration.

Template Parameters

T	Type to compare.

◆ Is()

Bool Is

Returns true if this type is the same as #T. {t.Is<T>()} is a shorthand for {t == GetDataType<T>()}.

Template Parameters

T	Type to compare.

Returns: True if this type is #T, false otherwise.

◆ AddConversion()

Result<void> AddConversion	(	CONVERSION_FLAGS	kind,
		Result< void >(*)(DEST &, const SRC &)	conversion
	)

◆ IsCastableFrom()

Bool IsCastableFrom

Checks if a value of type T can be cast safely to a value of this type. This holds if either both types are the same, have the same underlying type, or this type is Generic, or both types are reference or pointer types and the type to which this type points is a base type of the type to which T points (see IsBaseOfOrSame).

Template Parameters

T	Another data type.

Returns: True if a value of this data type can be safely cast from a value of type T.

◆ IsCastableTo()

Bool IsCastableTo

Checks if a value of this type can safely be cast to a value of type T.

See also: IsCastableFrom; IsBaseOfOrSame

Template Parameters

T	Another data type.

Returns: True if a value of this data type can be safely cast to a value of type T.

◆ Create() [2/2]

Result< Data > Create

static

Creates a Data and initializes it with the given type.

Template Parameters

T	Type of data which shall be created.

Returns: Data initialized to the given type on success.

◆ GetCopy()

Result< Data > GetCopy ( ) const

Returns a copy of the data.

◆ InitSet() [1/2]

void InitSet ( T && data )

private

Private: Copy or move specific data into a Data from the constructur.

Parameters

[in] data Data to copy or move to this.

◆ InitSet() [2/2]

void InitSet ( Data && data )

◆ SetImpl() [1/4]

Result< void > SetImpl	(	SRC &&	data,
		OverloadRank0
	)

◆ SetImpl() [2/4]

Result< void > SetImpl	(	Data &&	data,
		OverloadRank1
	)

◆ SetImpl() [3/4]

Result< void > SetImpl	(	const Data &	data,
		OverloadRank1
	)

◆ SetImpl() [4/4]

Result< void > SetImpl	(	Data &	data,
		OverloadRank1
	)

◆ GetPtr() [1/2]

T * GetPtr

Returns the pointer of the native data if its type matches the given type T, otherwise nullptr.

Template Parameters

T	The desired type.

Returns: Pointer to the data in native format.

◆ GetPtr() [2/2]

Data* GetPtr ( )

◆ Set() [1/4]

void Set ( const T & value )

◆ ToString()

String ToString	(	const T *	object,
		const FormatStatement *	formatStatement,
		Bool	checkDataType
	)

static

◆ DataTypePtr()

DataTypePtr ( const DataType & type )

◆ Get() [1/3]

Result<void> Get ( ) const

◆ Set() [2/4]

Result<void> Set ( const Data & value )

◆ Set() [3/4]

Result<void> Set ( Data & value )

◆ Set() [4/4]

Result<void> Set ( Data && value )

◆ operator==() [3/3]

Bool operator== ( const ConstDataPtr & other ) const

◆ Get() [2/3]

Result<void> Get ( ) const

◆ Get() [3/3]

Result<Data> Get ( )

◆ operator InternedIdPtr()

operator InternedIdPtr ( ) const

Variable Documentation

◆ KEEP

constexpr Bool KEEP

staticconstexpr

◆ InvalidArrayIndex

constexpr Int InvalidArrayIndex

staticconstexpr

Invalid array index (e.g. returned for an array index out of bounds).

◆ MAXON_FLEXIBLE_ARRAY_LENGTH

constexpr Int MAXON_FLEXIBLE_ARRAY_LENGTH

staticconstexpr

Use this as the bound of an array which is the last member of a class and shall have a flexible array length. Usually you can just leave the array bound empty (like in {Int b[];}), this non-standard extension declares a flexible array member and is supported by MSVC, Clang, ICC and GCC. However there are cases such as a member type with non-trivial destructor where a flexible array member isn't supported, then you can use MAXON_FLEXIBLE_ARRAY_LENGTH. Example:

struct MyStruct
{
  Int a;
  Int b[MAXON_FLEXIBLE_ARRAY_LENGTH];
};
...
MyStruct* s = MAXON_SAFE_PLACEMENT_NEW(NewMem(Char, SIZEOF(MyStruct) + SIZEOF(Int) * (cnt - MAXON_FLEXIBLE_ARRAY_LENGTH))) MyStruct();

Warning: This may only be used if the class has standard-layout. Also you have to implement default constructor, destructor and copy operations properly. Keep in mind that the actual class instance may have less elements than the compiler thinks.

◆ g_zeroMemory

const void* g_zeroMemory

extern

Points to a 32-byte-aligned block of ZERO_MEMORY_SIZE zero bytes. The memory will be write-protected if possible.

◆ ZERO_MEMORY_SIZE

constexpr Int ZERO_MEMORY_SIZE

staticconstexpr

The number of zero bytes available at g_zeroMemory.

◆ g_zeroPtr

constexpr const void* const g_zeroPtr

staticconstexpr

A global const void* value initialized to zero. Compilers will be able to do optimizations because they know the zero value.

◆ DONT_INITIALIZE

constexpr ENUM_DONT_INITIALIZE DONT_INITIALIZE

staticconstexpr

◆ IN_PLACE

constexpr IN_PLACE_TYPE IN_PLACE

staticconstexpr

◆ src

U && src

◆ OK

static const ERROR_OK OK

OK can be used for comparison with a Result value and as a return value of a function returning Result<void>. It indicates the success of an operation:

Result<void> Func()
{
  if (...)
    return OutOfMemoryError(MAXON_SOURCE_LOCATION);
  return OK;
}
 
if (Func() == OK)
{
   ...
}

It can also be used where an Error is expected, then it constructs a null Error reference which actually means that no error occurred.

◆ CheckedGetDataType

const DataTypeCache DataTypeCacheInstance<T, POLICY, ELEMENTARY>::_instance& CheckedGetDataType

◆ MAXON_ENUM_ORDERED_LIST

class maxon::SplineMapperInterface MAXON_ENUM_ORDERED_LIST

◆ _helper

NamedTuple< T... >::HelperStorage _helper

staticprivate

Detailed Description

Groups

Classes

Macros

Typedefs

Enumerations

Functions

Variables

Macro Definition Documentation

◆ MAXON_ATTRIBUTE_DLL_PUBLIC

◆ MAXON_ATTRIBUTE_NO_INLINE

◆ MAXON_ATTRIBUTE_FORCE_INLINE

◆ MAXON_ATTRIBUTE_FORCE_RELEASE_INLINE

◆ MAXON_ATTRIBUTE_USED

◆ MAXON_HAS_ATTRIBUTE_ALWAYS_CONST

◆ MAXON_ATTRIBUTE_ALWAYS_CONST

◆ MAXON_ATTRIBUTE_ALWAYS_PURE

◆ PRIVATE_MAXON_DEPRECATED_ENUMVALUE

◆ MAXON_DEPRECATED_ENUMVALUE

◆ MAXON_IMPLICIT

◆ MAXON_ATTRIBUTE_SYSCHAR_IS_CHAR

◆ MAXON_CONSTEXPR_EVAL

◆ PRIVATE_MAXON_AS_UTF8

◆ CONSTSTRING

◆ PRIVATE_MAXON_TRANSLATIONUNIT_FLAGS

◆ PRIVATE_MAXON_TRANSLATIONUNIT_FLAGS_2

◆ PRIVATE_MAXON_DETECT_MEMBER_HELPER1

◆ PRIVATE_MAXON_DETECT_MEMBER_HELPER2

◆ PRIVATE_MAXON_DETECT_MEMBER_HELPER3

◆ MAXON_DETECT_MEMBER_HELPER

◆ MAXON_SCOPE

◆ MAXON_WARN_MUTE_FUNCTION_LENGTH

◆ MAXON_WARN_MUTE_NAMING

◆ PRIVATE_MAXON_DATATYPE_A

◆ PRIVATE_MAXON_DATATYPE

◆ MAXON_DATATYPE

◆ PRIVATE_MAXON_DATATYPE_REGISTER

◆ PRIVATE_MAXON_DATATYPE_REGISTER_ENUM

◆ MAXON_DATATYPE_REGISTER

◆ PRIVATE_MAXON_DATATYPE_LOCAL_STATIC

◆ MAXON_DATATYPE_LOCAL

◆ PRIVATE_MAXON_DATATYPE_REGISTER_STRUCT_INIT

◆ PRIVATE_MAXON_DATATYPE_REGISTER_STRUCT_OFFSETS

◆ PRIVATE_MAXON_DATATYPE_REGISTER_STRUCT_B

◆ PRIVATE_MAXON_DATATYPE_REGISTER_STRUCT_A

◆ MAXON_DATATYPE_REGISTER_STRUCT

◆ SPLINEMAPPER_KNOT_GET_ID

◆ SPLINEMAPPER_KNOT_SET_ID

Typedef Documentation

◆ Int16

◆ UInt16

◆ Int32

◆ UInt32

◆ Int64

◆ UInt64

◆ Bool

◆ Float32

◆ Float64

◆ Char

◆ UChar

◆ Int

◆ UInt

◆ Float

◆ Byte

◆ Utf32Char

◆ Utf16Char

◆ SysChar

◆ type [1/11]

◆ type [2/11]

◆ type [3/11]

◆ type [4/11]

◆ type [5/11]

◆ type [6/11]

◆ type [7/11]

◆ type [8/11]

◆ type [9/11]

◆ DT

◆ type [10/11]

◆ HashInt

◆ type [11/11]

◆ attribute() [1/4]

◆ attribute() [2/4]

◆ attribute() [3/4]

◆ attribute() [4/4]