Groups | |
| GRADIENT_INTERPOLATION_TYPE | |
| SPLINEMAPPER_INTERPOLATION_TYPE | |
| SPLINEMAPPER_KNOT_FLAGS | |
| SPLINEMAPPER_RANGE_STATE | |
| SPLINEMAPPER_SPLINE_TYPE | |
Typedefs | |
| using | Int16 = int16_t |
| using | UInt16 = uint16_t |
| using | Int32 = int32_t |
| using | UInt32 = uint32_t |
| using | Int64 = int64_t |
| using | UInt64 = uint64_t |
| using | Bool = bool |
| using | Float32 = float |
| using | Float64 = double |
| using | Char = char |
| using | UChar = unsigned char |
| using | Int = Int64 |
| using | UInt = UInt64 |
| using | Float = Float64 |
| using | Utf32Char = char32_t |
| using | Utf16Char = char16_t |
| using | SysChar = char |
| using | 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 { LESS , EQUAL , GREATER , INCOMPARABLE } |
| enum class | EQUALITY { SHALLOW , DEEP } |
Functions | |
| __attribute__ ((always_inline)) const expr Float operator""_f(long double f) | |
| const String & | StringInterface_GetAndCacheConstString (const wchar_t *str, Int len) |
| const String & | StringInterface_GetAndCacheConstString (const Char *str, Int len, Int isUtf8) |
| constexpr Bool | PrivateIsUtf8 (const char *str, Int len) |
| const String & | operator""_s (const char *str, std::size_t cnt) |
| const String & | operator""_s (const wchar_t *str, std::size_t cnt) |
| template<typename T > | |
| String | GlobalToString (const T &object, const FormatStatement *formatStatement, Bool checkDataType=true) |
| virtual | ~EmptyVirtualClass () |
| template<typename T , typename E > | |
| E && | MakeDependentExpr (E &&value) |
| template<typename T > | |
| T * | addressof (T &x) |
| template<typename T > | |
| __attribute__ ((always_inline)) auto AssignCopy(T &dst | |
| 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 , 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 > | GetDataDescriptionValueI (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 Result< 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_DECLARATION (Class< DataDictionaryObjectRef >, DataDictionaryObjectClass, "net.maxon.class.datadictionaryobject") | |
| MAXON_DECLARATION (Class< DataDictionaryObjectRef >, DataDictionaryObjectLockedClass, "net.maxon.class.datadictionaryobjectlocked") | |
| MAXON_DECLARATION (Class< DataDictionaryObjectRef >, DataDictionaryObjectSyncedClass, "net.maxon.class.datadictionaryobjectsynced") | |
| MAXON_DECLARATION (Class< DataDictionaryReferenceObjectRef >, DataDictionaryObjectReferenceClass, "net.maxon.class.datadictionaryobjectreference") | |
| 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") | |
| 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") | |
| 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") | |
| 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") | |
| 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") | |
| 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") | |
| 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") | |
| 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") | |
| 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") | |
| 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") | |
| 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") | |
| 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") | |
| 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") | |
| 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") | |
| 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") | |
| 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") | |
| 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") | |
| 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") | |
| 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") | |
| 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") | |
| 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") | |
| 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") | |
| 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") | |
| 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") | |
| 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") | |
| 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") | |
| 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") | |
| 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") | |
| 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") | |
| 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") | |
| 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") | |
| 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) |
| 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 | MAXON_ENUM_ORDERED_LIST (COMPARERESULT, "net.maxon.datatype.enum.compareresult", EARLY) |
| 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) |
| 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) |
| template<> | |
| Result< void > | Get () const |
| template<> | |
| Result< Data > | Get () |
Variables | |
| enum | Byte |
| static const Bool | KEEP |
| static const Int | InvalidArrayIndex |
| static const Int | MAXON_FLEXIBLE_ARRAY_LENGTH |
| const void * | g_zeroMemory |
| static constexpr Int | ZERO_MEMORY_SIZE |
| static const void *const | g_zeroPtr |
| static const ENUM_DONT_INITIALIZE | DONT_INITIALIZE |
| static const 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 |
| #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();
| #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);
| #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)
| #define MAXON_ATTRIBUTE_FORCE_RELEASE_INLINE |
| #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)
Use MAXON_DEPRECATED_ENUMVALUE to mark an enum value being deprecated. This macro is processed by MSVC, Clang, GCC and Doxygen.
Example:
| #define MAXON_IMPLICIT |
Use MAXON_IMPLICIT to mark a constructor which may be used for implicit conversions. Example:
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.
| #define MAXON_ATTRIBUTE_SYSCHAR_IS_CHAR |
Internal.
| #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.
| T | Type of the expression (has to be an integral type). |
| X | The expression. |
| #define PRIVATE_MAXON_AS_UTF8 | ( | x | ) |
| #define CONSTSTRING | ( | x | ) |
| #define PRIVATE_MAXON_TRANSLATIONUNIT_FLAGS |
| #define PRIVATE_MAXON_TRANSLATIONUNIT_FLAGS_2 |
| #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.,
| #define MAXON_SCOPE |
Marks a block of code that is scoped for a certain reason.
| #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.
| #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.
| #define PRIVATE_MAXON_DATATYPE_A | ( | type, | |
| id | |||
| ) |
| #define PRIVATE_MAXON_DATATYPE | ( | type, | |
| id | |||
| ) |
| #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.
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.
| [in] | type | Type for which a DataType shall be implemented. |
| [in] | id | Unique identifier of the data type. |
| #define PRIVATE_MAXON_DATATYPE_REGISTER | ( | T, | |
| ret, | |||
| flags | |||
| ) |
| #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
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.
| [in] | type | Type for which a DataType shall be implemented. |
| #define PRIVATE_MAXON_DATATYPE_LOCAL_STATIC |
| #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.
| [in] | type | Type for which a local DataType shall be declared and implemented. |
| [in] | id | The unique identifier of the local data type. |
| #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.
| [in] | type | Type for which a DataType shall be implemented. |
| [in] | ... | List of the names of the member variables of type. |
| #define SPLINEMAPPER_KNOT_GET_ID | ( | flags | ) |
Gets the ID of a SplineMapperKnot. Usage:
| #define SPLINEMAPPER_KNOT_SET_ID | ( | flags, | |
| flag_id | |||
| ) |
Sets the ID of a SplineMapperKnot. Usage:
| using Int16 = int16_t |
16 bit signed integer datatype.
| using UInt16 = uint16_t |
16 bit unsigned integer datatype.
| using Int32 = int32_t |
32 bit signed integer datatype.
| using UInt32 = uint32_t |
32 bit unsigned integer datatype.
| using Int64 = int64_t |
64 bit signed integer datatype.
| using UInt64 = uint64_t |
64 bit unsigned integer datatype.
| using Bool = bool |
boolean type, possible values are only false/true, 8 bit
| using Float32 = float |
32 bit floating point value (float)
| using Float64 = double |
64 bit floating point value (double)
| using Char = char |
signed 8 bit character
| using UChar = unsigned char |
unsigned 8 bit character
current floating point model. right now it's adjusted to Float64==64 bit but maybe it's redefined to Float32 anytime
| using Utf32Char = char32_t |
32 bit unicode (UTF-32) character. Utf32Char is the datatype for a single 32 bit unicode character.
| using Utf16Char = char16_t |
16 bit unicode character. Note that complex unicodes can be composed of two individual 16 bit characters.
| 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).
| using type = T |
| 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 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.
| using type = T |
The result type will always be T.
| 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
| using DestructorPointer = void (*)(const void*) |
| 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:
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.
| 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>.
|
strong |
|
strong |
|
strong |
This enum defines flags for a DataType conversion.
| 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). |
|
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 | |
|
strong |
|
strong |
|
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) |
|
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.
| __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.
| [in] | value | Value to align. |
| [in] | alignment | Required alignment, must be a power of two. |
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.
| [in] | value | Pointer value to align. |
| [in] | alignment | Required alignment, must be a power of two. |
alignment closest to and not less than value). 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
| 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
| const String& maxon::operator""_s | ( | const char * | str, |
| std::size_t | cnt | ||
| ) |
Returns a String object of the characters passed in quotation marks. If the same characters are used in another place the String will still only be created once in memory. In the following example the second loop is far more efficient because the String is created only once whereas in the first loop the characters are converted to unicode and a new String object is created (and deleted) on each iteration.
As MSVC does not properly resolve \u sequences for char* you need to use the wchar_t version below for any characters >=0x80.
| const String& maxon::operator""_s | ( | const wchar_t * | str, |
| std::size_t | cnt | ||
| ) |
Returns a String object of the characters passed in quotation marks. This version can be used for unicode characters, e.g. L"t\u00e8st"_s.
| 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).
| [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. |
|
virtual |
| 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.
| T | A template type parameter on which the expression shall be made dependent. |
| [in] | value | The expression value. |
| T* std::maxon_std::addressof | ( | T & | x | ) |
| __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.
| enum maxon::ENUM_DONT_INITIALIZE maxon::MAXON_ENUM_LIST | ( | ENUM_DONT_INITIALIZE | ) |
| enum maxon::IN_PLACE_TYPE maxon::MAXON_ENUM_LIST | ( | IN_PLACE_TYPE | ) |
| maxon::Helper | ( | OverloadRank2 | , |
| T &obj | MAXON_MAKE_LISTPRIVATE_MAXON_DETECT_MEMBER_HELPER1,,,, | ||
| ) | -> decltype(obj. GetMemorySize (MAXON_MAKE_COMMA_LIST(PRIVATE_MAXON_DETECT_MEMBER_HELPER2,,,))) |
| maxon::Helper | ( | OverloadRank1 | , |
| T &obj | MAXON_MAKE_LISTPRIVATE_MAXON_DETECT_MEMBER_HELPER1,,,, | ||
| ) | -> decltype( GetMemorySize (obj MAXON_MAKE_LIST(PRIVATE_MAXON_DETECT_MEMBER_HELPER3,,,,))) |
| 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,,,,))) |
| 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.
| decltype(std::declval<T>().CopyFrom(std::declval<const T&>())) maxon::TestForCopyFromFunction | ( | OverloadRank1 | ) |
| std::false_type maxon::TestForCopyFromFunction | ( | OverloadRank0 | ) |
| __attribute__ | ( | (always_inline) | ) | & |
Calls new (&dst) T(src) or dst.CopyFrom(src) for non-trivial objector copy constructor.
Converting copy assignment.
| void maxon::Destruct | ( | const T * | object | ) |
Destructs the object.
| T | Type of object. |
| [out] | object | The object to destruct. |
| DestructorPointer maxon::GetDestructorPointer | ( | ) |
Returns a function to destruct an object of type T.
| T | Type of object. |
| 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.
| T | Type of object. |
| [out] | object | The object to reset. |
|
static |
Constructs a new object of type T with the given arguments.
| T | Type of object to construct. |
| [in] | args | Optional arguments for constructor or Init function. |
| 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.
| [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. |
| Result<void> maxon::MergeDataDictionariesPreferBase | ( | DataDictionary & | base, |
| const DataDictionary & | other, | ||
| Bool | mergeSubContainers | ||
| ) |
| Result<Data> maxon::GetDataDescriptionValueI | ( | const Id & | databaseScope, |
| const InternedId & | attributeData, | ||
| const ConstDataPtr & | keyPtr | ||
| ) |
GetDataDescriptionValueI returns a data description value from the database.
| [in] | databaseScope | Database id. |
| [in] | attributeData | Attribute to query. |
| [in] | keyPtr | Key to query. |
|
static |
Returns the defined description value of any attribute. Example usage:
| [in] | attribute | Attribute to find. |
| [in] | key | Value to return, e.g. DESCRIPTION::DATA::BASE::MAXVALUE. |
|
static |
|
static |
Returns the defined key value description of any attribute. Example usage:
| [in] | attribute | Attribute to find. |
| [in] | key | Value to return, e.g. DESCRIPTION::DATA::BASE::ENUM. |
| TT maxon::GetDefaultFromFidIfAvailable | ( | KEY && | key, |
| OverloadRank0 | |||
| ) |
| SFINAEHelper<TT, decltype(std::remove_reference<KEY>::type::DEFAULTVALUE)>::type maxon::GetDefaultFromFidIfAvailable | ( | KEY && | key, |
| OverloadRank2 | |||
| ) |
| ConstDataPtr maxon::GetDefaultValueKey | ( | ) |
Returns the Id of DESCRIPTION::DATA::BASE::DEFAULTVALUE.
| Result<void> maxon::TransferPropertyIfAvailable | ( | const SRCCLASS & | src, |
| PROPSRCTYPE && | srcType, | ||
| DSTCLASS & | dst, | ||
| PROPDSTTYPE && | dstType | ||
| ) |
TransferPropertyIfAvailable copies the value of src into dst if available.
| [in] | src | Source object. |
| [in] | srcType | Source property type id. |
| [in] | dst | Destination object. |
| [in] | dstType | Destination property type id. |
| maxon::MAXON_DECLARATION | ( | Class< DataDictionaryObjectRef > | , |
| DataDictionaryObjectEmptyClass | , | ||
| "net.maxon.class.datadictionaryobjectempty" | |||
| ) |
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::MAXON_DECLARATION | ( | Class< DataDictionaryObjectRef > | , |
| DataDictionaryObjectClass | , | ||
| "net.maxon.class.datadictionaryobject" | |||
| ) |
Implementation of the DataDictionaryObjectInterface without locking, so it's not threadsafe.
| maxon::MAXON_DECLARATION | ( | Class< DataDictionaryObjectRef > | , |
| DataDictionaryObjectLockedClass | , | ||
| "net.maxon.class.datadictionaryobjectlocked" | |||
| ) |
Implementation of the DataDictionaryObjectInterface with a spinlock protected hashmap, so it's threadsafe.
| maxon::MAXON_DECLARATION | ( | Class< DataDictionaryObjectRef > | , |
| DataDictionaryObjectSyncedClass | , | ||
| "net.maxon.class.datadictionaryobjectsynced" | |||
| ) |
Implementation of the DataDictionaryObjectInterface with a lockfree hashmap, so it's threadsafe.
| maxon::MAXON_DECLARATION | ( | Class< DataDictionaryReferenceObjectRef > | , |
| DataDictionaryObjectReferenceClass | , | ||
| "net.maxon.class.datadictionaryobjectreference" | |||
| ) |
Implementation of the DataDictionaryObjectInterface with a reference to a DataDictionary. This allows to pass DataDictionary to all functions expecting a DataDictionaryObjectRef.
| 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.
| [in] | reference | Pointer to a DataDictionary. |
| Result<DataDictionaryObjectRef> maxon::CreateDataDictionaryReferenceObject | ( | const DataDictionary * | reference | ) |
| Result<DataDictionary> maxon::GetDataDictionaryFromDataDictionaryObjectRef | ( | const DataDictionaryObjectRef & | ref | ) |
Returns a DataDictionary copy the given DataDictionaryObjectRef.
| [in] | ref | Reference to a DataDictionaryObjectRef. |
| ResultOk<const DataType&> maxon::PrivateGetDataType | ( | GenericArithmetic ** | , |
| OverloadRank0 | |||
| ) |
| ResultOk<const DataType&> maxon::PrivateGetDataType | ( | void ** | , |
| OverloadRank0 | |||
| ) |
| ResultOk<const DataType&> maxon::PrivateGetDataType | ( | std::nullptr_t ** | , |
| OverloadRank0 | |||
| ) |
| ResultOk<const DataType&> maxon::PrivateGetDataType | ( | InvalidType ** | , |
| OverloadRank0 | |||
| ) |
| SFINAEHelper<Result<const DataType&>, typename T::NonvirtualInterfaceMarker>::type maxon::PrivateGetDataType | ( | T ** | , |
| OverloadRank0 | |||
| ) |
| SFINAEHelper<Result<const DataType&>, typename T::InterfaceMarker>::type maxon::PrivateGetDataType | ( | T ** | , |
| OverloadRank1 | |||
| ) |
| Result<const DataType&> maxon::PrivateGetDataType | ( | void * | , |
| OverloadRank0 | |||
| ) |
| ResultOk<const DataType&> maxon::PrivateGetDataType | ( | DataType ** | , |
| OverloadRank0 | |||
| ) |
| ResultOk<const DataType&> maxon::PrivateGetDataType | ( | DataType::Primary ** | , |
| OverloadRank0 | |||
| ) |
| ResultOk<const DataType&> maxon::PrivateGetDataType | ( | TupleDataType ** | , |
| OverloadRank0 | |||
| ) |
| void maxon::PrivateDataTypeMarker | ( | T * | ) |
| 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.
| void* maxon::PrivateDataTypeMarker | ( | Char * | ) |
| maxon::MAXON_DECLARATION | ( | maxon::DataType | , |
| DT_Char | , | ||
| "char" | |||
| ) |
| maxon::ResultOk<const maxon::DataType&> maxon::PrivateGetDataType | ( | Char ** | , |
| maxon::OverloadRank2 | |||
| ) |
| maxon::MAXON_ASSERT_LEGAL_LAYOUT | ( | Char | ) |
| void* maxon::PrivateDataTypeMarker | ( | UChar * | ) |
| maxon::MAXON_DECLARATION | ( | maxon::DataType | , |
| DT_UChar | , | ||
| "uchar" | |||
| ) |
| maxon::ResultOk<const maxon::DataType&> maxon::PrivateGetDataType | ( | UChar ** | , |
| maxon::OverloadRank2 | |||
| ) |
| maxon::MAXON_ASSERT_LEGAL_LAYOUT | ( | UChar | ) |
| void* maxon::PrivateDataTypeMarker | ( | Int16 * | ) |
| maxon::MAXON_DECLARATION | ( | maxon::DataType | , |
| DT_Int16 | , | ||
| "int16" | |||
| ) |
| maxon::ResultOk<const maxon::DataType&> maxon::PrivateGetDataType | ( | Int16 ** | , |
| maxon::OverloadRank2 | |||
| ) |
| maxon::MAXON_ASSERT_LEGAL_LAYOUT | ( | Int16 | ) |
| void* maxon::PrivateDataTypeMarker | ( | UInt16 * | ) |
| maxon::MAXON_DECLARATION | ( | maxon::DataType | , |
| DT_UInt16 | , | ||
| "uint16" | |||
| ) |
| maxon::ResultOk<const maxon::DataType&> maxon::PrivateGetDataType | ( | UInt16 ** | , |
| maxon::OverloadRank2 | |||
| ) |
| maxon::MAXON_ASSERT_LEGAL_LAYOUT | ( | UInt16 | ) |
| void* maxon::PrivateDataTypeMarker | ( | Int32 * | ) |
| maxon::MAXON_DECLARATION | ( | maxon::DataType | , |
| DT_Int32 | , | ||
| "int32" | |||
| ) |
| maxon::ResultOk<const maxon::DataType&> maxon::PrivateGetDataType | ( | Int32 ** | , |
| maxon::OverloadRank2 | |||
| ) |
| maxon::MAXON_ASSERT_LEGAL_LAYOUT | ( | Int32 | ) |
| void* maxon::PrivateDataTypeMarker | ( | UInt32 * | ) |
| maxon::MAXON_DECLARATION | ( | maxon::DataType | , |
| DT_UInt32 | , | ||
| "uint32" | |||
| ) |
| maxon::ResultOk<const maxon::DataType&> maxon::PrivateGetDataType | ( | UInt32 ** | , |
| maxon::OverloadRank2 | |||
| ) |
| maxon::MAXON_ASSERT_LEGAL_LAYOUT | ( | UInt32 | ) |
| void* maxon::PrivateDataTypeMarker | ( | Int64 * | ) |
| maxon::MAXON_DECLARATION | ( | maxon::DataType | , |
| DT_Int64 | , | ||
| "int64" | |||
| ) |
| maxon::ResultOk<const maxon::DataType&> maxon::PrivateGetDataType | ( | Int64 ** | , |
| maxon::OverloadRank2 | |||
| ) |
| maxon::MAXON_ASSERT_LEGAL_LAYOUT | ( | Int64 | ) |
| void* maxon::PrivateDataTypeMarker | ( | UInt64 * | ) |
| maxon::MAXON_DECLARATION | ( | maxon::DataType | , |
| DT_UInt64 | , | ||
| "uint64" | |||
| ) |
| maxon::ResultOk<const maxon::DataType&> maxon::PrivateGetDataType | ( | UInt64 ** | , |
| maxon::OverloadRank2 | |||
| ) |
| maxon::MAXON_ASSERT_LEGAL_LAYOUT | ( | UInt64 | ) |
| void* maxon::PrivateDataTypeMarker | ( | Utf16Char * | ) |
| maxon::MAXON_DECLARATION | ( | maxon::DataType | , |
| DT_Utf16Char | , | ||
| "utf16char" | |||
| ) |
| maxon::ResultOk<const maxon::DataType&> maxon::PrivateGetDataType | ( | Utf16Char ** | , |
| maxon::OverloadRank2 | |||
| ) |
| maxon::MAXON_ASSERT_LEGAL_LAYOUT | ( | Utf16Char | ) |
| void* maxon::PrivateDataTypeMarker | ( | Utf32Char * | ) |
| maxon::MAXON_DECLARATION | ( | maxon::DataType | , |
| DT_Utf32Char | , | ||
| "utf32char" | |||
| ) |
| maxon::ResultOk<const maxon::DataType&> maxon::PrivateGetDataType | ( | Utf32Char ** | , |
| maxon::OverloadRank2 | |||
| ) |
| maxon::MAXON_ASSERT_LEGAL_LAYOUT | ( | Utf32Char | ) |
| void* maxon::PrivateDataTypeMarker | ( | Float32 * | ) |
| maxon::MAXON_DECLARATION | ( | maxon::DataType | , |
| DT_Float32 | , | ||
| "float32" | |||
| ) |
| maxon::ResultOk<const maxon::DataType&> maxon::PrivateGetDataType | ( | Float32 ** | , |
| maxon::OverloadRank2 | |||
| ) |
| maxon::MAXON_ASSERT_LEGAL_LAYOUT | ( | Float32 | ) |
| void* maxon::PrivateDataTypeMarker | ( | Float64 * | ) |
| maxon::MAXON_DECLARATION | ( | maxon::DataType | , |
| DT_Float64 | , | ||
| "float64" | |||
| ) |
| maxon::ResultOk<const maxon::DataType&> maxon::PrivateGetDataType | ( | Float64 ** | , |
| maxon::OverloadRank2 | |||
| ) |
| maxon::MAXON_ASSERT_LEGAL_LAYOUT | ( | Float64 | ) |
| void* maxon::PrivateDataTypeMarker | ( | Bool * | ) |
| maxon::MAXON_DECLARATION | ( | maxon::DataType | , |
| DT_Bool | , | ||
| "bool" | |||
| ) |
| maxon::ResultOk<const maxon::DataType&> maxon::PrivateGetDataType | ( | Bool ** | , |
| maxon::OverloadRank2 | |||
| ) |
| maxon::MAXON_ASSERT_LEGAL_LAYOUT | ( | Bool | ) |
| void* maxon::PrivateDataTypeMarker | ( | Byte * | ) |
| maxon::MAXON_DECLARATION | ( | maxon::DataType | , |
| DT_Byte | , | ||
| "byte" | |||
| ) |
| maxon::ResultOk<const maxon::DataType&> maxon::PrivateGetDataType | ( | Byte ** | , |
| maxon::OverloadRank2 | |||
| ) |
| maxon::MAXON_ASSERT_LEGAL_LAYOUT | ( | Byte | ) |
| void* maxon::PrivateDataTypeMarker | ( | AInt * | ) |
| maxon::MAXON_DECLARATION | ( | maxon::DataType | , |
| DT_AInt | , | ||
| "int" | |||
| ) |
| maxon::ResultOk<const maxon::DataType&> maxon::PrivateGetDataType | ( | AInt ** | , |
| maxon::OverloadRank2 | |||
| ) |
| maxon::MAXON_ASSERT_LEGAL_LAYOUT | ( | AInt | ) |
| void* maxon::PrivateDataTypeMarker | ( | AUInt * | ) |
| maxon::MAXON_DECLARATION | ( | maxon::DataType | , |
| DT_AUInt | , | ||
| "uint" | |||
| ) |
| maxon::ResultOk<const maxon::DataType&> maxon::PrivateGetDataType | ( | AUInt ** | , |
| maxon::OverloadRank2 | |||
| ) |
| maxon::MAXON_ASSERT_LEGAL_LAYOUT | ( | AUInt | ) |
| void* maxon::PrivateDataTypeMarker | ( | AFloat * | ) |
| maxon::MAXON_DECLARATION | ( | maxon::DataType | , |
| DT_AFloat | , | ||
| "float" | |||
| ) |
| maxon::ResultOk<const maxon::DataType&> maxon::PrivateGetDataType | ( | AFloat ** | , |
| maxon::OverloadRank2 | |||
| ) |
| maxon::MAXON_ASSERT_LEGAL_LAYOUT | ( | AFloat | ) |
| void* maxon::PrivateDataTypeMarker | ( | UniqueHash * | ) |
| maxon::MAXON_DECLARATION | ( | maxon::DataType | , |
| DT_UniqueHash | , | ||
| "net.maxon.datatype.hash" | |||
| ) |
| maxon::ResultOk<const maxon::DataType&> maxon::PrivateGetDataType | ( | UniqueHash ** | , |
| maxon::OverloadRank2 | |||
| ) |
| maxon::MAXON_ASSERT_LEGAL_LAYOUT | ( | UniqueHash | ) |
| void* maxon::PrivateDataTypeMarker | ( | Id * | ) |
| maxon::MAXON_DECLARATION | ( | maxon::DataType | , |
| DT_Id | , | ||
| "net.maxon.datatype.id" | |||
| ) |
| maxon::ResultOk<const maxon::DataType&> maxon::PrivateGetDataType | ( | Id ** | , |
| maxon::OverloadRank2 | |||
| ) |
| maxon::MAXON_ASSERT_LEGAL_LAYOUT | ( | Id | ) |
| void* maxon::PrivateDataTypeMarker | ( | LiteralId * | ) |
| maxon::MAXON_DECLARATION | ( | maxon::DataType | , |
| DT_LiteralId | , | ||
| "net.maxon.datatype.literalid" | |||
| ) |
| maxon::ResultOk<const maxon::DataType&> maxon::PrivateGetDataType | ( | LiteralId ** | , |
| maxon::OverloadRank2 | |||
| ) |
| maxon::MAXON_ASSERT_LEGAL_LAYOUT | ( | LiteralId | ) |
| void* maxon::PrivateDataTypeMarker | ( | InternedId * | ) |
| maxon::MAXON_DECLARATION | ( | maxon::DataType | , |
| DT_InternedId | , | ||
| "net.maxon.datatype.internedid" | |||
| ) |
| maxon::ResultOk<const maxon::DataType&> maxon::PrivateGetDataType | ( | InternedId ** | , |
| maxon::OverloadRank2 | |||
| ) |
| maxon::MAXON_ASSERT_LEGAL_LAYOUT | ( | InternedId | ) |
| void* maxon::PrivateDataTypeMarker | ( | Data * | ) |
| maxon::MAXON_DECLARATION | ( | maxon::DataType | , |
| DT_Data | , | ||
| "net.maxon.datatype.data" | |||
| ) |
| maxon::ResultOk<const maxon::DataType&> maxon::PrivateGetDataType | ( | Data ** | , |
| maxon::OverloadRank2 | |||
| ) |
| maxon::MAXON_ASSERT_LEGAL_LAYOUT | ( | Data | ) |
| void* maxon::PrivateDataTypeMarker | ( | UnitType * | ) |
| maxon::MAXON_DECLARATION | ( | maxon::DataType | , |
| DT_UnitType | , | ||
| "net.maxon.datatype.unittype" | |||
| ) |
| maxon::ResultOk<const maxon::DataType&> maxon::PrivateGetDataType | ( | UnitType ** | , |
| maxon::OverloadRank2 | |||
| ) |
| maxon::MAXON_ASSERT_LEGAL_LAYOUT | ( | UnitType | ) |
| void* maxon::PrivateDataTypeMarker | ( | SourceLocation * | ) |
| maxon::MAXON_DECLARATION | ( | maxon::DataType | , |
| DT_SourceLocation | , | ||
| "net.maxon.datatype.sourcelocation" | |||
| ) |
| maxon::ResultOk<const maxon::DataType&> maxon::PrivateGetDataType | ( | SourceLocation ** | , |
| maxon::OverloadRank2 | |||
| ) |
| maxon::MAXON_ASSERT_LEGAL_LAYOUT | ( | SourceLocation | ) |
| void* maxon::PrivateDataTypeMarker | ( | DelegateBase * | ) |
| maxon::MAXON_DECLARATION | ( | maxon::DataType | , |
| DT_DelegateBase | , | ||
| "net.maxon.datatype.delegatebase" | |||
| ) |
| maxon::ResultOk<const maxon::DataType&> maxon::PrivateGetDataType | ( | DelegateBase ** | , |
| maxon::OverloadRank2 | |||
| ) |
| maxon::MAXON_ASSERT_LEGAL_LAYOUT | ( | DelegateBase | ) |
| ResultOk<const DataType&> maxon::PrivateGetEnumDataType | ( | T * | , |
| OverloadRank0 | |||
| ) |
| ResultOk<const DataType&> maxon::PrivateGetDataType | ( | long ** | , |
| OverloadRank0 | |||
| ) |
| ResultOk<const DataType&> maxon::PrivateGetDataType | ( | unsigned long ** | , |
| OverloadRank0 | |||
| ) |
| ResultOk<const DataType&> maxon::PrivateGetDataType | ( | ParametricType ** | , |
| OverloadRank0 | |||
| ) |
| ResultOk<const DataType&> maxon::PrivateGetDataType | ( | ComponentDescriptor ** | , |
| OverloadRank0 | |||
| ) |
| Result<DataType> maxon::PrivateGetDataType | ( | T *** | , |
| OverloadRank0 | |||
| ) |
| Result<DataType> maxon::PrivateGetDataType | ( | Block< T > ** | , |
| OverloadRank0 | |||
| ) |
| Result<DataType> maxon::PrivateGetDataType | ( | StridedBlock< T > ** | , |
| OverloadRank0 | |||
| ) |
| Result<DataType> maxon::PrivateGetDataType | ( | Opt< T > ** | , |
| OverloadRank0 | |||
| ) |
| Result<DataType> maxon::PrivateGetDataType | ( | Result< T > ** | , |
| OverloadRank0 | |||
| ) |
| Result<DataType> maxon::PrivateGetDataType | ( | AtomicBool ** | , |
| OverloadRank0 | |||
| ) |
| Result<DataType> maxon::PrivateGetDataType | ( | Atomic8< T > ** | , |
| OverloadRank0 | |||
| ) |
| Result<DataType> maxon::PrivateGetDataType | ( | Atomic16< T > ** | , |
| OverloadRank0 | |||
| ) |
| Result<DataType> maxon::PrivateGetDataType | ( | Atomic32< T > ** | , |
| OverloadRank0 | |||
| ) |
| Result<DataType> maxon::PrivateGetDataType | ( | Atomic64< T > ** | , |
| OverloadRank0 | |||
| ) |
| Result<DataType> maxon::PrivateGetDataType | ( | AtomicPtr< T > ** | , |
| OverloadRank0 | |||
| ) |
| Result<DataType> maxon::PrivateGetDataType | ( | AtomicFloatType< T > ** | , |
| OverloadRank0 | |||
| ) |
| Result<DataType> maxon::PrivateGetDataType | ( | BaseArray< T > ** | , |
| OverloadRank0 | |||
| ) |
| Result<TupleDataType> maxon::PrivateGetDataType | ( | Tuple< T... > ** | , |
| OverloadRank0 | |||
| ) |
| Result<TupleDataType> maxon::PrivateGetDataType | ( | T ** | , |
| OverloadRank0 | |||
| ) |
| Result<DelegateDataType> maxon::PrivateGetDataType | ( | Delegate< R(ARGS...)> ** | , |
| OverloadRank2 | |||
| ) |
| 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).
| T | Type for which the DataType shall be obtained. |
| POLICY | An optional policy for the operation. |
Returns the DataType for the given C++ type.
| T | Type of which the DataType representation shall be obtained. |
| POLICY | Optional parameter to modify the data type resolution. |
| ResultOk<const DataType&> maxon::PrivateGetDataType | ( | Generic ** | , |
| OverloadRank0 | |||
| ) |
| void* maxon::PrivateDataTypeMarker | ( | ConstDataPtr * | ) |
| maxon::MAXON_DECLARATION | ( | maxon::DataType | , |
| DT_ConstDataPtr | , | ||
| "net.maxon.datatype.constdataptr" | |||
| ) |
| maxon::ResultOk<const maxon::DataType&> maxon::PrivateGetDataType | ( | ConstDataPtr ** | , |
| maxon::OverloadRank2 | |||
| ) |
| maxon::MAXON_ASSERT_LEGAL_LAYOUT | ( | ConstDataPtr | ) |
| void* maxon::PrivateDataTypeMarker | ( | TrivialDataPtr * | ) |
| maxon::MAXON_DECLARATION | ( | maxon::DataType | , |
| DT_TrivialDataPtr | , | ||
| "net.maxon.datatype.trivialdataptr" | |||
| ) |
| maxon::ResultOk<const maxon::DataType&> maxon::PrivateGetDataType | ( | TrivialDataPtr ** | , |
| maxon::OverloadRank2 | |||
| ) |
| maxon::MAXON_ASSERT_LEGAL_LAYOUT | ( | TrivialDataPtr | ) |
| void* maxon::PrivateDataTypeMarker | ( | DataPtr * | ) |
| maxon::MAXON_DECLARATION | ( | maxon::DataType | , |
| DT_DataPtr | , | ||
| "net.maxon.datatype.dataptr" | |||
| ) |
| maxon::ResultOk<const maxon::DataType&> maxon::PrivateGetDataType | ( | DataPtr ** | , |
| maxon::OverloadRank2 | |||
| ) |
| maxon::MAXON_ASSERT_LEGAL_LAYOUT | ( | DataPtr | ) |
| void* maxon::PrivateDataTypeMarker | ( | MoveDataPtr * | ) |
| maxon::MAXON_DECLARATION | ( | maxon::DataType | , |
| DT_MoveDataPtr | , | ||
| "net.maxon.datatype.movedataptr" | |||
| ) |
| maxon::ResultOk<const maxon::DataType&> maxon::PrivateGetDataType | ( | MoveDataPtr ** | , |
| maxon::OverloadRank2 | |||
| ) |
| maxon::MAXON_ASSERT_LEGAL_LAYOUT | ( | MoveDataPtr | ) |
| void* maxon::PrivateDataTypeMarker | ( | ForwardingDataPtr * | ) |
| maxon::MAXON_DECLARATION | ( | maxon::DataType | , |
| DT_ForwardingDataPtr | , | ||
| "net.maxon.datatype.forwardingdataptr" | |||
| ) |
| maxon::ResultOk<const maxon::DataType&> maxon::PrivateGetDataType | ( | ForwardingDataPtr ** | , |
| maxon::OverloadRank2 | |||
| ) |
| maxon::MAXON_ASSERT_LEGAL_LAYOUT | ( | ForwardingDataPtr | ) |
| void* maxon::PrivateDataTypeMarker | ( | Member * | ) |
| maxon::MAXON_DECLARATION | ( | maxon::DataType | , |
| DT_Member | , | ||
| "net.maxon.datatype.member" | |||
| ) |
| maxon::ResultOk<const maxon::DataType&> maxon::PrivateGetDataType | ( | Member ** | , |
| maxon::OverloadRank2 | |||
| ) |
| maxon::MAXON_ASSERT_LEGAL_LAYOUT | ( | Member | ) |
| Result<TupleDataType> maxon::PrivateGetDataType | ( | NamedTuple< T... > ** | , |
| OverloadRank0 | |||
| ) |
| Result<DataType> maxon::PrivateGetDataType | ( | std::integral_constant< T, C > ** | , |
| OverloadRank0 | |||
| ) |
| enum maxon::CONVERSION_FLAGS maxon::MAXON_ENUM_FLAGS | ( | CONVERSION_FLAGS | ) |
| enum maxon::GET_DATATYPE_POLICY maxon::MAXON_ENUM_FLAGS | ( | GET_DATATYPE_POLICY | ) |
| maxon::MAXON_DETECT_MEMBER_HELPER | ( | DescribeIO | , |
| const DataSerializeInterface & | |||
| ) |
| Result<void> maxon::DescribeIO | ( | const T & | s, |
| const DataSerializeInterface & | dsi | ||
| ) |
| enum maxon::DATATYPEMODE maxon::MAXON_ENUM_LIST | ( | DATATYPEMODE | ) |
| Result<void*> maxon::DecltypeNewInstanceHelper | ( | const void * | ) |
|
static |
|
static |
| enum maxon::INNERMOST_MEMBER Int32 maxon::MAXON_ENUM_ORDERED_LIST | ( | INNERMOST_MEMBER | ) |
| enum maxon::COMPARERESULT maxon::MAXON_ENUM_ORDERED_LIST | ( | COMPARERESULT | , |
| "net.maxon.datatype.enum.compareresult" | , | ||
| EARLY | |||
| ) |
| enum maxon::EQUALITY maxon::MAXON_ENUM_LIST | ( | EQUALITY | , |
| "net.maxon.datatype.enum.equality" | , | ||
| EARLY | |||
| ) |
| Bool maxon::LexicographicalGreaterThan | ( | ) |
| 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.
| [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, ...). |
| Bool maxon::LexicographicalLessThan | ( | ) |
| 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.
| [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, ...). |
| COMPARERESULT maxon::LexicographicalCompare | ( | ) |
| 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.
| [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, ...). |
| COMPARERESULT maxon::Compare | ( | const GradientKnot & | a, |
| const GradientKnot & | b | ||
| ) |
| maxon::MAXON_DATATYPE | ( | SplineMapperKnot | , |
| "net.maxon.datatype.splinemapperknot" | |||
| ) |
| DataDictionaryIterator | ( | const DataDictionaryInterface * | dict, |
| Bool | end | ||
| ) |
| std::conditional<std::is_void<T>::value, typename IsFidClass<KEY>::type, T>::type GetOrDefault | ( | KEY && | key | ) | const |
| DataDictionaryIterator | ( | const DataDictionaryObjectInterface * | dict, |
| Bool | end | ||
| ) |
| std::conditional<std::is_void<T>::value, typename IsFidClass<KEY>::type, T>::type GetOrDefault | ( | KEY && | key | ) | const |
| 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.
| T | Type to compare. |
| Bool Is |
Returns true if this type is the same as #T. {t.Is<T>()} is a shorthand for {t == GetDataType<T>()}.
| T | Type to compare. |
| Result<void> AddConversion | ( | CONVERSION_FLAGS | kind, |
| Result< void >(*)(DEST &, const SRC &) | conversion | ||
| ) |
| 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).
| T | Another data type. |
T. | Bool IsCastableTo |
Checks if a value of this type can safely be cast to a value of type T.
| T | Another data type. |
T.
|
private |
| void InitSet | ( | Data && | data | ) |
|
private |
|
private |
|
private |
|
private |
| T * GetPtr | ( | void | ) |
Returns the pointer of the native data if its type matches the given type T, otherwise nullptr.
| T | The desired type. |
| Data* GetPtr | ( | void | ) |
| void Set | ( | const T & | value | ) |
|
static |
| DataTypePtr | ( | const DataType & | type | ) |
| Result<void> Get | ( | void | ) | const |
| Result<void> Get | ( | void | ) | const |
|
strong |
A byte.
|
static |
|
static |
Invalid array index (e.g. returned for an array index out of bounds).
|
static |
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:
|
extern |
Points to a 32-byte-aligned block of ZERO_MEMORY_SIZE zero bytes. The memory will be write-protected if possible.
|
staticconstexpr |
The number of zero bytes available at g_zeroMemory.
|
static |
A global const void* value initialized to zero. Compilers will be able to do optimizations because they know the zero value.
|
static |
|
static |
| U && src |
| 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:
It can also be used where an Error is expected, then it constructs a null Error reference which actually means that no error occurred.
| const DataTypeCache DataTypeCacheInstance<T, POLICY, ELEMENTARY>::_instance& CheckedGetDataType |
| class maxon::SplineMapperInterface MAXON_ENUM_ORDERED_LIST |
|
staticprivate |