Data Types

Detailed Description

Groups

 GRADIENT_INTERPOLATION_TYPE
 

Namespaces

 std::maxon_std
 
 maxon::details
 

Classes

struct  IntFloat32
 
struct  IntFloat64
 
struct  IntType< BYTES >
 
struct  IntType< 1 >
 
struct  IntType< 2 >
 
struct  IntType< 4 >
 
struct  IntType< 8 >
 
struct  UIntType< BYTES >
 
struct  UIntType< 1 >
 
struct  UIntType< 2 >
 
struct  UIntType< 4 >
 
struct  UIntType< 8 >
 
struct  StandardType< T, INTEGRAL >
 
struct  StandardType< T, true >
 
class  Block< T, STRIDED, MOVE >
 
class  Result< T >
 
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  AlignedStorage< SIZE, ALIGN >
 
class  BoolLValue
 
class  DataDictionaryInterface
 
class  DataDictionaryIteratorInterface
 
class  DataDictionaryIterator
 
class  DataDictionaryObjectInterface
 
class  DataDictionaryReferenceObjectInterface
 
struct  IsSimdElementType< T, CHECK >
 
struct  IsSimdElementType< T, typename SFINAEHelper< void, typename T::VectorStrideType >::type >
 
struct  SimdInfo
 
class  SimdBlock< T >
 
class  OpaquePtr< PTR >
 
class  PrivateOpaque< T, CHECK >
 
class  PrivateOpaque< T *, void >
 
class  PrivateOpaque< T, typename SFINAEHelper< void, typename T::ReferencedType >::type >
 
class  Opt< T >
 
struct  AInt
 
struct  AUInt
 
struct  AFloat
 
class  DataTypeCache
 
class  DataTypeCacheInstance< T, POLICY, ELEMENTARY >
 
class  DataTypeCacheInstance< T, POLICY, true >
 
struct  Member
 
class  MemberType< T, ID >
 
class  MemberType< T &, ID >
 
class  MemberType< T &&, ID >
 
struct  GetMemberType< T >
 
struct  GetMemberType< MemberType< T, ID > >
 
struct  GetMemberType< MemberType< T, InternedId::NULL_VALUE > >
 
struct  SubstituteReferenceByPointer< T >
 
struct  SubstituteReferenceByPointer< T & >
 
struct  SubstituteReferenceByPointer< T && >
 
class  NamedTuple< T >
 
struct  TypeArguments
 
class  TupleValue
 
class  FunctionDataType
 
struct  DataMemBlock
 
class  DataType
 
class  Data
 
struct  IsZeroInitialized< Data >
 
class  TrivialConstDataPtr
 
class  ConstDataPtr::Wrapper< T, CHECK >
 
class  ConstDataPtr
 
class  DataPtr
 
class  MoveDataPtr
 
struct  ForwardingDataPtr
 
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  DataTypeLib
 
class  TupleDataType
 
class  DelegateDataType
 
class  EnumDataType
 
class  ParameterType
 
class  RefCountedCString
 
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
 

Macros

#define MAXON_ATTRIBUTE_DLL_PUBLIC
 
#define MAXON_ATTRIBUTE_NO_INLINE
 
#define MAXON_ATTRIBUTE_FORCE_INLINE
 
#define MAXON_ATTRIBUTE_USED
 
#define PRIVATE_MAXON_DEPRECATED_ENUMVALUE(name, value, reason)
 
#define MAXON_DEPRECATED_ENUMVALUE(name, value, reason)
 
#define MAXON_IMPLICIT
 
#define MAXON_ATTRIBUTE_SYSCHAR_IS_CHAR
 
#define MAXON_CONSTEXPR_EVAL(T, X)
 
#define PRIVATE_MAXON_AS_UTF8(x)
 
#define CONSTSTRING(x)
 
#define PRIVATE_MAXON_TRANSLATIONUNIT_FLAGS
 
#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, result)
 
#define MAXON_DATATYPE_SCALAR(type, id)
 
#define PRIVATE_MAXON_DATATYPE(type, id)
 
#define MAXON_DATATYPE(type, id)
 
#define PRIVATE_MAXON_DATATYPE_REGISTER(type, ret, flags)
 
#define PRIVATE_MAXON_DATATYPE_REGISTER_ENUM(enumtype, 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, ...)
 

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_signed< T >::value, typename IntType< sizeof(T)>::type, typename UIntType< sizeof(T)>::type >::type >::type
 
using type = T
 
using InitMTable = void(*)()
 
template<typename T >
using Opaque = typename PrivateOpaque< T, void >::type
 
using ResultMem = ResultMemT< Bool >
 

Enumerations

enum  ENUM_DONT_INITIALIZE { VALUE }
 
enum  IN_PLACE_TYPE { VALUE }
 
enum  INNERMOST_MEMBER : Int32
 
enum  CONVERSION_FLAGS {
  NONE,
  IDENTITY,
  NARROWING,
  WIDENING_LOSSY,
  WIDENING_LOSSLESS,
  EXPANDING,
  REDUCING,
  WIDENING_MASK
}
 
enum  GET_DATATYPE_POLICY {
  NONE,
  GENERIC_FOR_UNKNOWN,
  ERROR_FOR_UNKNOWN,
  NO_DECAY,
  ALLOW_BASEARRAY,
  RESULT_FOR_UNKNOWN_MASK
}
 
enum  DATATYPEMODE {
  SMALLISPOD,
  SMALL,
  BIG
}
 
enum  COMPARERESULT {
  LESS,
  EQUAL,
  GREATER,
  INCOMPARABLE
}
 
enum  EQUALITY {
  SHALLOW,
  DEEP
}
 

Functions

 IntFloat32 ()=default
 
 IntFloat32 (Int32 a)
 
 IntFloat32 (UInt32 a)
 
 IntFloat32 (Float32 a)
 
const IntFloat32operator= (const IntFloat32 &other)
 
UInt32 GetUInt () const
 
 IntFloat64 ()=default
 
 IntFloat64 (Int64 a)
 
 IntFloat64 (UInt64 a)
 
 IntFloat64 (Float64 a)
 
const IntFloat64operator= (const IntFloat64 &other)
 
UInt64 GetUInt () const
 
 __attribute__ ((always_inline)) const expr Float operator"" _f(long double f)
 
constexpr UInt UIntPow (UInt x, Int exp)
 
constexpr UInt PrivateGetHashCode (const char *str, Int len)
 
constexpr UInt PrivateGetHashCode (const Utf32Char *str, Int len)
 
const StringStringInterface_GetAndCacheConstString (const wchar_t *str, Int len)
 
const StringStringInterface_GetAndCacheConstString (const Char *str, Int len, Int isUtf8)
 
constexpr Bool PrivateIsUtf8 (const char *str, Int len)
 
const Stringoperator"" _s (const char *str, std::size_t cnt)
 
const Stringoperator"" _s (const wchar_t *str, std::size_t cnt)
 
template<typename T >
String GlobalToString (const T &object, const FormatStatement *formatStatement, Bool checkDataType=true)
 
virtual ~EmptyVirtualClass ()
 
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)
 
Bool MaxonStart (int argc, char **argv, InitMTable initSystemTable)
 
Bool MaxonEnd ()
 
 Helper (OverloadRank2, T &obj MAXON_MAKE_LIST(PRIVATE_MAXON_DETECT_MEMBER_HELPER1,,,,)) -> decltype(obj. GetMemorySize(MAXON_MAKE_COMMA_LIST(PRIVATE_MAXON_DETECT_MEMBER_HELPER2,,,)))
 
 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 >
std::false_type TestForCopyFromFunction (OverloadRank0)
 
template<typename T >
 __attribute__ ((always_inline)) Result< void > NewCopy(T &dst
 
template<typename T , typename U >
 __attribute__ ((always_inline)) Result< void > AssignCopyConvert(T &dst
 
template<typename T >
void Destruct (const T *object)
 
Result< void > MergeDataDictionaries (DataDictionary &base, const DataDictionary &other, Bool mergeSubContainers)
 
Result< DataGetDataDescriptionValueI (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 ATTRIBUTETYPE >
static Result< typename IsFidClass< ATTRIBUTETYPE >::type > GetDataDescriptionValue2 (ATTRIBUTETYPE &&attribute, const ConstDataPtr &key)
 
template<typename ATTRIBUTETYPE , typename KEY >
static Result< typename IsFidClass< KEY >::type > GetDataDescriptionValueFromKey (ATTRIBUTETYPE &&attribute, KEY &&key)
 
template<typename KEY >
IsFidClass< KEY >::type GetDefaultFromFidIfAvailable (KEY &&key, OverloadRank0)
 
template<typename KEY >
SFINAEHelper< typename IsFidClass< KEY >::type, 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<typename T , GET_DATATYPE_POLICY POLICY>
Result< const DataType * > CheckedGetDataType ()
 
template<GET_DATATYPE_POLICY POLICY>
ResultOk< const DataType * > PrivateGetDataType (GenericArithmetic *, OverloadRank0)
 
template<GET_DATATYPE_POLICY POLICY, typename T >
SFINAEHelper< Result< const DataType * >, typename T::Unresolved >::type PrivateGetDataType (T *, OverloadRank0)
 
template<GET_DATATYPE_POLICY POLICY, typename T >
SFINAEHelper< Result< const DataType * >, typename T::StaticMTable >::type PrivateGetDataType (T *, OverloadRank1)
 
template<GET_DATATYPE_POLICY POLICY>
Result< const DataType * > PrivateGetDataType (void *, OverloadRank0)
 
template<GET_DATATYPE_POLICY POLICY, typename T >
Result< const DataType * > PrivateGetDataType (T **, OverloadRank0)
 
template<GET_DATATYPE_POLICY POLICY, typename T >
Result< const DataType * > PrivateGetDataType (Pointer< T > *, OverloadRank0)
 
template<GET_DATATYPE_POLICY POLICY, typename T >
Result< const DataType * > PrivateGetDataType (StrongRef< T > *, OverloadRank0)
 
template<GET_DATATYPE_POLICY POLICY, typename T >
Result< const DataType * > PrivateGetDataType (StrongCOWRef< T > *, OverloadRank0)
 
template<GET_DATATYPE_POLICY POLICY, typename T >
Result< const DataType * > PrivateGetDataType (UniqueRef< T > *, OverloadRank0)
 
template<GET_DATATYPE_POLICY POLICY, typename T >
Result< const DataType * > PrivateGetDataType (Block< T > *, OverloadRank0)
 
template<GET_DATATYPE_POLICY POLICY, typename T >
Result< const DataType * > PrivateGetDataType (StridedBlock< T > *, OverloadRank0)
 
template<GET_DATATYPE_POLICY POLICY, typename T >
Result< const DataType * > PrivateGetDataType (Opt< T > *, OverloadRank0)
 
template<GET_DATATYPE_POLICY POLICY, typename T >
Result< const DataType * > PrivateGetDataType (Result< T > *, OverloadRank0)
 
template<GET_DATATYPE_POLICY POLICY, typename T >
Result< const DataType * > PrivateGetDataType (OpaquePtr< T > *, OverloadRank0)
 
template<GET_DATATYPE_POLICY POLICY, typename T >
std::enable_if<(Int(POLICY) &Int(GET_DATATYPE_POLICY::ALLOW_BASEARRAY)) !=0, Result< const DataType * > >::type PrivateGetDataType (BaseArray< T > *, OverloadRank0)
 
template<GET_DATATYPE_POLICY POLICY, typename... T>
Result< const TupleDataType * > PrivateGetDataType (Tuple< T... > *, OverloadRank0)
 
template<GET_DATATYPE_POLICY POLICY, typename R , typename... ARGS>
Result< const DelegateDataType * > PrivateGetDataType (Delegate< R(ARGS...)> *, OverloadRank2)
 
template<GET_DATATYPE_POLICY POLICY>
ResultOk< const DataType * > PrivateGetDataType (const DataType **, OverloadRank0)
 
template<GET_DATATYPE_POLICY POLICY>
ResultOk< const DataType * > PrivateGetDataType (const TupleDataType **, OverloadRank0)
 
String ToString (const TupleDataType *type, const FormatStatement *formatStatement, Bool=false)
 
template<typename T >
void PrivateDataTypeMarker (T *)
 
 MAXON_REGISTRY (const DataType *, DataTypes, "net.maxon.registry.datatypes")
 
void * PrivateDataTypeMarker (Char *)
 
 MAXON_DECLARATION (const maxon::DataType *, DT_Char, "char")
 
template<maxon::GET_DATATYPE_POLICY >
maxon::ResultOk< const maxon::DataType * > PrivateGetDataType (Char *, maxon::OverloadRank2)
 
void * PrivateDataTypeMarker (UChar *)
 
 MAXON_DECLARATION (const maxon::DataType *, DT_UChar, "uchar")
 
template<maxon::GET_DATATYPE_POLICY >
maxon::ResultOk< const maxon::DataType * > PrivateGetDataType (UChar *, maxon::OverloadRank2)
 
void * PrivateDataTypeMarker (Int16 *)
 
 MAXON_DECLARATION (const maxon::DataType *, DT_Int16, "int16")
 
template<maxon::GET_DATATYPE_POLICY >
maxon::ResultOk< const maxon::DataType * > PrivateGetDataType (Int16 *, maxon::OverloadRank2)
 
void * PrivateDataTypeMarker (UInt16 *)
 
 MAXON_DECLARATION (const maxon::DataType *, DT_UInt16, "uint16")
 
template<maxon::GET_DATATYPE_POLICY >
maxon::ResultOk< const maxon::DataType * > PrivateGetDataType (UInt16 *, maxon::OverloadRank2)
 
void * PrivateDataTypeMarker (Int32 *)
 
 MAXON_DECLARATION (const maxon::DataType *, DT_Int32, "int32")
 
template<maxon::GET_DATATYPE_POLICY >
maxon::ResultOk< const maxon::DataType * > PrivateGetDataType (Int32 *, maxon::OverloadRank2)
 
void * PrivateDataTypeMarker (UInt32 *)
 
 MAXON_DECLARATION (const maxon::DataType *, DT_UInt32, "uint32")
 
template<maxon::GET_DATATYPE_POLICY >
maxon::ResultOk< const maxon::DataType * > PrivateGetDataType (UInt32 *, maxon::OverloadRank2)
 
void * PrivateDataTypeMarker (Int64 *)
 
 MAXON_DECLARATION (const maxon::DataType *, DT_Int64, "int64")
 
template<maxon::GET_DATATYPE_POLICY >
maxon::ResultOk< const maxon::DataType * > PrivateGetDataType (Int64 *, maxon::OverloadRank2)
 
void * PrivateDataTypeMarker (UInt64 *)
 
 MAXON_DECLARATION (const maxon::DataType *, DT_UInt64, "uint64")
 
template<maxon::GET_DATATYPE_POLICY >
maxon::ResultOk< const maxon::DataType * > PrivateGetDataType (UInt64 *, maxon::OverloadRank2)
 
void * PrivateDataTypeMarker (Utf16Char *)
 
 MAXON_DECLARATION (const maxon::DataType *, DT_Utf16Char, "utf16char")
 
template<maxon::GET_DATATYPE_POLICY >
maxon::ResultOk< const maxon::DataType * > PrivateGetDataType (Utf16Char *, maxon::OverloadRank2)
 
void * PrivateDataTypeMarker (Utf32Char *)
 
 MAXON_DECLARATION (const maxon::DataType *, DT_Utf32Char, "utf32char")
 
template<maxon::GET_DATATYPE_POLICY >
maxon::ResultOk< const maxon::DataType * > PrivateGetDataType (Utf32Char *, maxon::OverloadRank2)
 
void * PrivateDataTypeMarker (Float32 *)
 
 MAXON_DECLARATION (const maxon::DataType *, DT_Float32, "float32")
 
template<maxon::GET_DATATYPE_POLICY >
maxon::ResultOk< const maxon::DataType * > PrivateGetDataType (Float32 *, maxon::OverloadRank2)
 
void * PrivateDataTypeMarker (Float64 *)
 
 MAXON_DECLARATION (const maxon::DataType *, DT_Float64, "float64")
 
template<maxon::GET_DATATYPE_POLICY >
maxon::ResultOk< const maxon::DataType * > PrivateGetDataType (Float64 *, maxon::OverloadRank2)
 
void * PrivateDataTypeMarker (Bool *)
 
 MAXON_DECLARATION (const maxon::DataType *, DT_Bool, "bool")
 
template<maxon::GET_DATATYPE_POLICY >
maxon::ResultOk< const maxon::DataType * > PrivateGetDataType (Bool *, maxon::OverloadRank2)
 
void * PrivateDataTypeMarker (Byte *)
 
 MAXON_DECLARATION (const maxon::DataType *, DT_Byte, "byte")
 
template<maxon::GET_DATATYPE_POLICY >
maxon::ResultOk< const maxon::DataType * > PrivateGetDataType (Byte *, maxon::OverloadRank2)
 
void * PrivateDataTypeMarker (Id *)
 
 MAXON_DECLARATION (const maxon::DataType *, DT_Id, "net.maxon.datatype.id")
 
template<maxon::GET_DATATYPE_POLICY >
maxon::ResultOk< const maxon::DataType * > PrivateGetDataType (Id *, maxon::OverloadRank2)
 
void * PrivateDataTypeMarker (InternedId *)
 
 MAXON_DECLARATION (const maxon::DataType *, DT_InternedId, "net.maxon.datatype.internedid")
 
template<maxon::GET_DATATYPE_POLICY >
maxon::ResultOk< const maxon::DataType * > PrivateGetDataType (InternedId *, maxon::OverloadRank2)
 
void * PrivateDataTypeMarker (Data *)
 
 MAXON_DECLARATION (const maxon::DataType *, DT_Data, "net.maxon.datatype.data")
 
template<maxon::GET_DATATYPE_POLICY >
maxon::ResultOk< const maxon::DataType * > PrivateGetDataType (Data *, maxon::OverloadRank2)
 
void * PrivateDataTypeMarker (UnitType *)
 
 MAXON_DECLARATION (const maxon::DataType *, DT_UnitType, "net.maxon.datatype.unittype")
 
template<maxon::GET_DATATYPE_POLICY >
maxon::ResultOk< const maxon::DataType * > PrivateGetDataType (UnitType *, maxon::OverloadRank2)
 
void * PrivateDataTypeMarker (SourceLocation *)
 
 MAXON_DECLARATION (const maxon::DataType *, DT_SourceLocation, "net.maxon.datatype.sourcelocation")
 
template<maxon::GET_DATATYPE_POLICY >
maxon::ResultMemT< const maxon::DataType * > PrivateGetDataType (SourceLocation *, maxon::OverloadRank2)
 
 MAXON_ASSERT_LEGAL_LAYOUT (SourceLocation)
 
void * PrivateDataTypeMarker (DelegateBase *)
 
 MAXON_DECLARATION (const maxon::DataType *, DT_DelegateBase, "net.maxon.datatype.delegatebase")
 
template<maxon::GET_DATATYPE_POLICY >
maxon::ResultMemT< const maxon::DataType * > PrivateGetDataType (DelegateBase *, maxon::OverloadRank2)
 
 MAXON_ASSERT_LEGAL_LAYOUT (DelegateBase)
 
void * PrivateDataTypeMarker (AInt *)
 
 MAXON_DECLARATION (const maxon::DataType *, DT_AInt, "int")
 
template<maxon::GET_DATATYPE_POLICY >
maxon::ResultMemT< const maxon::DataType * > PrivateGetDataType (AInt *, maxon::OverloadRank2)
 
 MAXON_ASSERT_LEGAL_LAYOUT (AInt)
 
void * PrivateDataTypeMarker (AUInt *)
 
 MAXON_DECLARATION (const maxon::DataType *, DT_AUInt, "uint")
 
template<maxon::GET_DATATYPE_POLICY >
maxon::ResultMemT< const maxon::DataType * > PrivateGetDataType (AUInt *, maxon::OverloadRank2)
 
 MAXON_ASSERT_LEGAL_LAYOUT (AUInt)
 
void * PrivateDataTypeMarker (AFloat *)
 
 MAXON_DECLARATION (const maxon::DataType *, DT_AFloat, "float")
 
template<maxon::GET_DATATYPE_POLICY >
maxon::ResultMemT< const maxon::DataType * > PrivateGetDataType (AFloat *, maxon::OverloadRank2)
 
 MAXON_ASSERT_LEGAL_LAYOUT (AFloat)
 
template<Bool , typename T >
Result< const DataType * > PrivateGetEnumDataType (T *, OverloadRank0)
 
template<GET_DATATYPE_POLICY POLICY>
ResultOk< const DataType * > PrivateGetDataType (ParametricType *, OverloadRank0)
 
template<GET_DATATYPE_POLICY POLICY>
ResultOk< const DataType * > PrivateGetDataType (ComponentDescriptor *, OverloadRank0)
 
template<typename T , GET_DATATYPE_POLICY POLICY>
const DataTypeGetDataType ()
 
template<GET_DATATYPE_POLICY POLICY>
ResultOk< const DataType * > PrivateGetDataType (Generic *, OverloadRank0)
 
void * PrivateDataTypeMarker (ConstDataPtr *)
 
 MAXON_DECLARATION (const maxon::DataType *, DT_ConstDataPtr, "net.maxon.datatype.constdataptr")
 
template<maxon::GET_DATATYPE_POLICY >
maxon::ResultMemT< const maxon::DataType * > PrivateGetDataType (ConstDataPtr *, maxon::OverloadRank2)
 
 MAXON_ASSERT_LEGAL_LAYOUT (ConstDataPtr)
 
void * PrivateDataTypeMarker (DataPtr *)
 
 MAXON_DECLARATION (const maxon::DataType *, DT_DataPtr, "net.maxon.datatype.dataptr")
 
template<maxon::GET_DATATYPE_POLICY >
maxon::ResultMemT< const maxon::DataType * > PrivateGetDataType (DataPtr *, maxon::OverloadRank2)
 
 MAXON_ASSERT_LEGAL_LAYOUT (DataPtr)
 
void * PrivateDataTypeMarker (MoveDataPtr *)
 
 MAXON_DECLARATION (const maxon::DataType *, DT_MoveDataPtr, "net.maxon.datatype.movedataptr")
 
template<maxon::GET_DATATYPE_POLICY >
maxon::ResultMemT< const maxon::DataType * > PrivateGetDataType (MoveDataPtr *, maxon::OverloadRank2)
 
 MAXON_ASSERT_LEGAL_LAYOUT (MoveDataPtr)
 
void * PrivateDataTypeMarker (ForwardingDataPtr *)
 
 MAXON_DECLARATION (const maxon::DataType *, DT_ForwardingDataPtr, "net.maxon.datatype.forwardingdataptr")
 
template<maxon::GET_DATATYPE_POLICY >
maxon::ResultMemT< const maxon::DataType * > PrivateGetDataType (ForwardingDataPtr *, maxon::OverloadRank2)
 
 MAXON_ASSERT_LEGAL_LAYOUT (ForwardingDataPtr)
 
void * PrivateDataTypeMarker (Member *)
 
 MAXON_DECLARATION (const maxon::DataType *, DT_Member, "net.maxon.datatype.member")
 
template<maxon::GET_DATATYPE_POLICY >
maxon::ResultMemT< const maxon::DataType * > PrivateGetDataType (Member *, maxon::OverloadRank2)
 
 MAXON_ASSERT_LEGAL_LAYOUT (Member)
 
template<GET_DATATYPE_POLICY POLICY, typename... T>
Result< const TupleDataType * > PrivateGetDataType (NamedTuple< T... > *, OverloadRank0)
 
enum maxon::INNERMOST_MEMBER Int32 MAXON_ENUM_ORDERED_LIST (INNERMOST_MEMBER)
 
template<GET_DATATYPE_POLICY POLICY, typename T , T C>
Result< const DataType * > PrivateGetDataType (std::integral_constant< T, C > *, OverloadRank0)
 
enum maxon::CONVERSION_FLAGS MAXON_ENUM_FLAGS (CONVERSION_FLAGS)
 
 MAXON_ASSERT_STANDARD_LAYOUT (DataType)
 
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::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_INTERFACE_NONVIRTUAL (GradientInterface, MAXON_REFERENCE_COPY_ON_WRITE, "net.maxon.interface.gradient")
 
MAXON_METHOD Result< Gradient * > AllocAlphaGradient ()
 
MAXON_METHOD GradientGetAlphaGradient ()
 
MAXON_METHOD void SetIsAlphaGradient (Bool alphaGradient)
 
MAXON_METHOD Bool IsAlphaGradient () const
 
MAXON_METHOD COMPARERESULT Compare (const GradientInterface *arg2) const
 
MAXON_METHOD UInt GetHashCode () const
 
MAXON_METHOD Result< GradientRenderData > InitRender (const TransformColorDelegate &transformColorDelegate) const
 
 MAXON_INTERFACE_NONVIRTUAL (GradientRenderDataInterface, MAXON_REFERENCE_COPY_ON_WRITE, "net.maxon.interface.gradientrenderdata")
 
MAXON_METHOD Color CalcGradientPixel (Float pos) const
 
MAXON_METHOD Int GetKnotCount () const
 
MAXON_METHOD const GradientKnotGetKnot (Int index) const
 
MAXON_METHOD const BaseArray< GradientKnot > & GetKnots () const
 
MAXON_METHOD COMPARERESULT Compare (const GradientRenderDataInterface *arg2) const
 
MAXON_METHOD UInt GetHashCode () const
 
 DataDictionaryIterator (const DataDictionaryInterface *dict, Bool end)
 
template<typename KEY >
IsFidClass< KEY >::type GetOrDefault (KEY &&key) const
 
 DataDictionaryIterator (const DataDictionaryObjectInterface *dict, Bool end)
 
template<typename KEY >
IsFidClass< KEY >::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< DataCreate ()
 
Result< DataGetCopy () const
 
template<typename T >
void InitSet (T &&data)
 
template<>
void InitSet (Data &&data)
 
template<typename T >
Result< void > SetImpl (T &&data, OverloadRank0)
 
template<typename T >
T * GetPtr ()
 
template<>
DataGetPtr ()
 
template<typename T >
void Set (const T &value)
 
static String ToString (const T *object, const FormatStatement *formatStatement, Bool checkDataType)
 
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< DataGet ()
 

Variables

enum Byte
 
Int32   i
 
Float32   f
 
union {
   Int32   i
 
   Float32   f
 
}; 
 
Int64   i
 
Float64   f
 
union {
   Int64   i
 
   Float64   f
 
}; 
 
static const Bool KEEP
 
static const Int InvalidArrayIndex
 
static const Int MAXON_FLEXIBLE_ARRAY_LENGTH
 
static const ENUM_DONT_INITIALIZE DONT_INITIALIZE
 
static const IN_PLACE_TYPE IN_PLACE
 
template<typename T >
decltype(std::declval< T >().CopyFrom(std::declval< const T & >())) TestForCopyFromFunction (OverloadRank1)
 
const T & 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
 
 CUBICKNOT
 
 SMOOTHKNOT
 
 LINEARKNOT
 
 NONE
 
 EXP_UP
 
 EXP_DOWN
 
 BLEND
 
Color col
 
Float brightness
 
Float pos
 
Float bias
 
Int32 index
 
GRADIENT_INTERPOLATION_TYPE interpolation
 

Friends

Bool operator== (const IntFloat32 &a, const IntFloat32 &b)
 
Bool operator!= (const IntFloat32 &a, const IntFloat32 &b)
 
Bool operator== (const IntFloat64 &a, const IntFloat64 &b)
 
Bool operator!= (const IntFloat64 &a, const IntFloat64 &b)
 

Knots

MAXON_METHOD Int GetKnotCount () const
 
MAXON_METHOD Result< IntInsertKnot (const GradientKnot &knot, Bool keepId=false)
 
MAXON_METHOD Result< void > RemoveKnot (Int index)
 
MAXON_METHOD GradientKnot GetKnot (Int index) const
 
MAXON_METHOD Result< void > SetKnot (Int index, const GradientKnot &k)
 
MAXON_METHOD void ConvertToAlphaGradient ()
 
MAXON_METHOD void SortKnots ()
 
MAXON_METHOD Result< BoolInvertKnots ()
 
MAXON_METHOD Result< BoolDoubleKnots ()
 
MAXON_METHOD Bool DistributeKnots ()
 
MAXON_METHOD void Flush ()
 

Macro Definition Documentation

◆ MAXON_ATTRIBUTE_DLL_PUBLIC

#define MAXON_ATTRIBUTE_DLL_PUBLIC

◆ MAXON_ATTRIBUTE_NO_INLINE

#define MAXON_ATTRIBUTE_NO_INLINE

◆ MAXON_ATTRIBUTE_FORCE_INLINE

#define MAXON_ATTRIBUTE_FORCE_INLINE

◆ MAXON_ATTRIBUTE_USED

#define MAXON_ATTRIBUTE_USED

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

◆ MAXON_CONSTEXPR_EVAL

#define MAXON_CONSTEXPR_EVAL (   T,
 
)

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
TType of the expression (has to be an integral type).
XThe 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_DETECT_MEMBER_HELPER1

#define PRIVATE_MAXON_DETECT_MEMBER_HELPER1 (   x,
  i,
 
)

◆ PRIVATE_MAXON_DETECT_MEMBER_HELPER2

#define PRIVATE_MAXON_DETECT_MEMBER_HELPER2 (   x,
  i,
 
)

◆ PRIVATE_MAXON_DETECT_MEMBER_HELPER3

#define PRIVATE_MAXON_DETECT_MEMBER_HELPER3 (   x,
  i,
 
)

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

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

◆ PRIVATE_MAXON_DATATYPE_A

#define PRIVATE_MAXON_DATATYPE_A (   type,
  id,
  result 
)

◆ MAXON_DATATYPE_SCALAR

#define MAXON_DATATYPE_SCALAR (   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");

You don't have to declare data types for interfaces, this is done automatically.

Parameters
[in]typeType for which a DataType shall be implemented.
[in]idUnique identifier of the data type.

◆ PRIVATE_MAXON_DATATYPE_REGISTER

#define PRIVATE_MAXON_DATATYPE_REGISTER (   type,
  ret,
  flags 
)

◆ PRIVATE_MAXON_DATATYPE_REGISTER_ENUM

#define PRIVATE_MAXON_DATATYPE_REGISTER_ENUM (   enumtype,
  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

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]typeType 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]typeType for which a local DataType shall be declared and implemented.
[in]idThe unique identifier of the local data type.

◆ PRIVATE_MAXON_DATATYPE_REGISTER_STRUCT_INIT

#define PRIVATE_MAXON_DATATYPE_REGISTER_STRUCT_INIT (   x,
  i,
 
)

◆ PRIVATE_MAXON_DATATYPE_REGISTER_STRUCT_OFFSETS

#define PRIVATE_MAXON_DATATYPE_REGISTER_STRUCT_OFFSETS (   x,
  i,
 
)

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

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

struct Member
{
const DataType* type;
Id name;
};
MAXON_DATATYPE_REGISTER_STRUCT(Member, type, name);
Parameters
[in]typeType for which a DataType shall be implemented.
[in]...List of the names of the member variables of #type.

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

◆ 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_signed<T>::value, typename IntType<sizeof(T)>::type, typename UIntType<sizeof(T)>::type>::type>::type

◆ 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

◆ Opaque

using Opaque = typename PrivateOpaque<T, void>::type

◆ 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 

◆ INNERMOST_MEMBER

enum INNERMOST_MEMBER : Int32
strong

◆ CONVERSION_FLAGS

enum CONVERSION_FLAGS
strong

This enum defines flags for a DataType conversion.

See also
AddConversion
Convert
Enumerator
NONE 
IDENTITY 

The conversion contains an identity conversion such as from Vector to Color.

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.

EXPANDING 

The conversion contains a expanding conversion such as from a scalar to a vector (or a lower-dimensional vector to a higher-dimensional vector).

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

WIDENING_MASK 

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

NO_DECAY 

Set this flag if the template argument T of GetDataType shall not be decayed (by default the type is decayed so that T&, T&&, const T, const T&, const T&& all return the same as GetDataType<T>()).

ALLOW_BASEARRAY 
RESULT_FOR_UNKNOWN_MASK 

◆ DATATYPEMODE

enum DATATYPEMODE
strong
Enumerator
SMALLISPOD 
SMALL 
BIG 

◆ COMPARERESULT

enum COMPARERESULT
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

◆ IntFloat32() [1/4]

IntFloat32 ( )
default

◆ IntFloat32() [2/4]

IntFloat32 ( Int32  a)
explicit

◆ IntFloat32() [3/4]

IntFloat32 ( UInt32  a)
explicit

◆ IntFloat32() [4/4]

IntFloat32 ( Float32  a)
explicit

◆ operator=() [1/2]

const IntFloat32& operator= ( const IntFloat32 other)

◆ GetUInt() [1/2]

UInt32 GetUInt ( ) const

◆ IntFloat64() [1/4]

IntFloat64 ( )
default

◆ IntFloat64() [2/4]

IntFloat64 ( Int64  a)
explicit

◆ IntFloat64() [3/4]

IntFloat64 ( UInt64  a)
explicit

◆ IntFloat64() [4/4]

IntFloat64 ( Float64  a)
explicit

◆ operator=() [2/2]

const IntFloat64& operator= ( const IntFloat64 other)

◆ GetUInt() [2/2]

UInt64 GetUInt ( ) const

◆ __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]valueValue to align.
[in]alignmentRequired 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]valuePointer value to align.
[in]alignmentRequired alignment, must be a power of two.
Returns
Aligned pointer value (multiple of alignment closest to and not less than value).

◆ UIntPow()

constexpr UInt maxon::UIntPow ( UInt  x,
Int  exp 
)

◆ PrivateGetHashCode() [1/2]

constexpr UInt maxon::PrivateGetHashCode ( const char *  str,
Int  len 
)

◆ PrivateGetHashCode() [2/2]

constexpr UInt maxon::PrivateGetHashCode ( const Utf32Char str,
Int  len 
)

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

◆ operator"" _s() [1/2]

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.

for (...)
{
if (s.FindIndex(String("A is created each time.")) == 0) ...
}
for (...)
{
if (s.FindIndex("B is created only once."_s) == 42) ...
}

As MSVC does not properly resolve sequences for char* you need to use the wchar_t version below for any characters >=0x80.

◆ operator"" _s() [2/2]

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.

◆ 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]objectSome object to be converted to a string.
[in]formatStatementNullptr or additional formatting instruction. See also format_integer.
[in]checkDataTypeMust be set to true (the default value), only for internal use.
Returns
The converted result.

◆ ~EmptyVirtualClass()

virtual ~EmptyVirtualClass ( )
virtual

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

◆ MaxonStart()

Bool maxon::MaxonStart ( int  argc,
char **  argv,
InitMTable  initSystemTable 
)

◆ MaxonEnd()

Bool maxon::MaxonEnd ( )

◆ 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__() [2/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()

std::false_type maxon::TestForCopyFromFunction ( OverloadRank0  )

◆ __attribute__() [3/4]

__attribute__ ( (always_inline)  ) &

Calls new (&dst) T(src) or dst.CopyFrom(src) for non-trivial objector copy constructor.

Copy assignment.

◆ __attribute__() [4/4]

__attribute__ ( (always_inline)  ) &

Converting copy assignment.

◆ Destruct()

void maxon::Destruct ( const T *  object)

Destructs the 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]baseDictionary to merge as the base.
[in]otherDictionary to merge into base. this values will overwrite values with the same key in 'base'.
[in]mergeSubContainersTrue 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.

◆ GetDataDescriptionValueI()

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

GetDataDescriptionValueI returns a data description value from the data base.

Parameters
[in]databaseScopeDatabase id.
[in]attributeDataAttribute to query.
[in]keyPtrKey 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;
Parameters
[in]attributeAttribute to find.
[in]keyValue 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 Result<typename IsFidClass<ATTRIBUTETYPE>::type> 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;
Parameters
[in]attributeAttribute to find.
[in]keyValue 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]

IsFidClass<KEY>::type maxon::GetDefaultFromFidIfAvailable ( KEY &&  key,
OverloadRank0   
)

◆ GetDefaultFromFidIfAvailable() [2/2]

SFINAEHelper<typename IsFidClass<KEY>::type, 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]srcSource object.
[in]srcTypeSource property type id.
[in]dstDestination object.
[in]dstTypeDestination property type id.
Returns
OK on success.

◆ MAXON_DECLARATION() [1/33]

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_DECLARATION() [2/33]

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

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

◆ MAXON_DECLARATION() [3/33]

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

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

◆ MAXON_DECLARATION() [4/33]

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

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

◆ MAXON_DECLARATION() [5/33]

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.

◆ 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]referencePointer 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]refReference to a DataDictionaryObjectRef.
Returns
DataDictionary with the copy of all data.

◆ CheckedGetDataType()

Result< const DataType * > CheckedGetDataType ( )

◆ PrivateGetDataType() [1/52]

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

◆ PrivateGetDataType() [2/52]

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

◆ PrivateGetDataType() [3/52]

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

◆ PrivateGetDataType() [4/52]

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

◆ PrivateGetDataType() [5/52]

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

◆ PrivateGetDataType() [6/52]

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

◆ PrivateGetDataType() [7/52]

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

◆ PrivateGetDataType() [8/52]

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

◆ PrivateGetDataType() [9/52]

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

◆ PrivateGetDataType() [10/52]

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

◆ PrivateGetDataType() [11/52]

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

◆ PrivateGetDataType() [12/52]

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

◆ PrivateGetDataType() [13/52]

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

◆ PrivateGetDataType() [14/52]

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

◆ PrivateGetDataType() [15/52]

std::enable_if<(Int(POLICY) & Int(GET_DATATYPE_POLICY::ALLOW_BASEARRAY)) != 0, Result<const DataType*> >::type maxon::PrivateGetDataType ( BaseArray< T > *  ,
OverloadRank0   
)

◆ PrivateGetDataType() [16/52]

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

◆ PrivateGetDataType() [17/52]

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

◆ PrivateGetDataType() [18/52]

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

◆ PrivateGetDataType() [19/52]

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

◆ ToString() [1/2]

String maxon::ToString ( const TupleDataType type,
const FormatStatement formatStatement,
Bool  = false 
)

◆ PrivateDataTypeMarker() [1/29]

void maxon::PrivateDataTypeMarker ( T *  )

◆ MAXON_REGISTRY()

maxon::MAXON_REGISTRY ( const 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/29]

void* maxon::PrivateDataTypeMarker ( Char )

◆ MAXON_DECLARATION() [6/33]

maxon::MAXON_DECLARATION ( const maxon::DataType ,
DT_Char  ,
"char"   
)

◆ PrivateGetDataType() [20/52]

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

◆ PrivateDataTypeMarker() [3/29]

void* maxon::PrivateDataTypeMarker ( UChar )

◆ MAXON_DECLARATION() [7/33]

maxon::MAXON_DECLARATION ( const maxon::DataType ,
DT_UChar  ,
"uchar"   
)

◆ PrivateGetDataType() [21/52]

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

◆ PrivateDataTypeMarker() [4/29]

void* maxon::PrivateDataTypeMarker ( Int16 )

◆ MAXON_DECLARATION() [8/33]

maxon::MAXON_DECLARATION ( const maxon::DataType ,
DT_Int16  ,
"int16"   
)

◆ PrivateGetDataType() [22/52]

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

◆ PrivateDataTypeMarker() [5/29]

void* maxon::PrivateDataTypeMarker ( UInt16 )

◆ MAXON_DECLARATION() [9/33]

maxon::MAXON_DECLARATION ( const maxon::DataType ,
DT_UInt16  ,
"uint16"   
)

◆ PrivateGetDataType() [23/52]

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

◆ PrivateDataTypeMarker() [6/29]

void* maxon::PrivateDataTypeMarker ( Int32 )

◆ MAXON_DECLARATION() [10/33]

maxon::MAXON_DECLARATION ( const maxon::DataType ,
DT_Int32  ,
"int32"   
)

◆ PrivateGetDataType() [24/52]

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

◆ PrivateDataTypeMarker() [7/29]

void* maxon::PrivateDataTypeMarker ( UInt32 )

◆ MAXON_DECLARATION() [11/33]

maxon::MAXON_DECLARATION ( const maxon::DataType ,
DT_UInt32  ,
"uint32"   
)

◆ PrivateGetDataType() [25/52]

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

◆ PrivateDataTypeMarker() [8/29]

void* maxon::PrivateDataTypeMarker ( Int64 )

◆ MAXON_DECLARATION() [12/33]

maxon::MAXON_DECLARATION ( const maxon::DataType ,
DT_Int64  ,
"int64"   
)

◆ PrivateGetDataType() [26/52]

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

◆ PrivateDataTypeMarker() [9/29]

void* maxon::PrivateDataTypeMarker ( UInt64 )

◆ MAXON_DECLARATION() [13/33]

maxon::MAXON_DECLARATION ( const maxon::DataType ,
DT_UInt64  ,
"uint64"   
)

◆ PrivateGetDataType() [27/52]

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

◆ PrivateDataTypeMarker() [10/29]

void* maxon::PrivateDataTypeMarker ( Utf16Char )

◆ MAXON_DECLARATION() [14/33]

maxon::MAXON_DECLARATION ( const maxon::DataType ,
DT_Utf16Char  ,
"utf16char"   
)

◆ PrivateGetDataType() [28/52]

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

◆ PrivateDataTypeMarker() [11/29]

void* maxon::PrivateDataTypeMarker ( Utf32Char )

◆ MAXON_DECLARATION() [15/33]

maxon::MAXON_DECLARATION ( const maxon::DataType ,
DT_Utf32Char  ,
"utf32char"   
)

◆ PrivateGetDataType() [29/52]

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

◆ PrivateDataTypeMarker() [12/29]

void* maxon::PrivateDataTypeMarker ( Float32 )

◆ MAXON_DECLARATION() [16/33]

maxon::MAXON_DECLARATION ( const maxon::DataType ,
DT_Float32  ,
"float32"   
)

◆ PrivateGetDataType() [30/52]

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

◆ PrivateDataTypeMarker() [13/29]

void* maxon::PrivateDataTypeMarker ( Float64 )

◆ MAXON_DECLARATION() [17/33]

maxon::MAXON_DECLARATION ( const maxon::DataType ,
DT_Float64  ,
"float64"   
)

◆ PrivateGetDataType() [31/52]

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

◆ PrivateDataTypeMarker() [14/29]

void* maxon::PrivateDataTypeMarker ( Bool )

◆ MAXON_DECLARATION() [18/33]

maxon::MAXON_DECLARATION ( const maxon::DataType ,
DT_Bool  ,
"bool"   
)

◆ PrivateGetDataType() [32/52]

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

◆ PrivateDataTypeMarker() [15/29]

void* maxon::PrivateDataTypeMarker ( Byte )

◆ MAXON_DECLARATION() [19/33]

maxon::MAXON_DECLARATION ( const maxon::DataType ,
DT_Byte  ,
"byte"   
)

◆ PrivateGetDataType() [33/52]

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

◆ PrivateDataTypeMarker() [16/29]

void* maxon::PrivateDataTypeMarker ( Id )

◆ MAXON_DECLARATION() [20/33]

maxon::MAXON_DECLARATION ( const maxon::DataType ,
DT_Id  ,
"net.maxon.datatype.id"   
)

◆ PrivateGetDataType() [34/52]

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

◆ PrivateDataTypeMarker() [17/29]

void* maxon::PrivateDataTypeMarker ( InternedId )

◆ MAXON_DECLARATION() [21/33]

maxon::MAXON_DECLARATION ( const maxon::DataType ,
DT_InternedId  ,
"net.maxon.datatype.internedid"   
)

◆ PrivateGetDataType() [35/52]

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

◆ PrivateDataTypeMarker() [18/29]

void* maxon::PrivateDataTypeMarker ( Data )

◆ MAXON_DECLARATION() [22/33]

maxon::MAXON_DECLARATION ( const maxon::DataType ,
DT_Data  ,
"net.maxon.datatype.data"   
)

◆ PrivateGetDataType() [36/52]

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

◆ PrivateDataTypeMarker() [19/29]

void* maxon::PrivateDataTypeMarker ( UnitType )

◆ MAXON_DECLARATION() [23/33]

maxon::MAXON_DECLARATION ( const maxon::DataType ,
DT_UnitType  ,
"net.maxon.datatype.unittype"   
)

◆ PrivateGetDataType() [37/52]

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

◆ PrivateDataTypeMarker() [20/29]

void* maxon::PrivateDataTypeMarker ( SourceLocation )

◆ MAXON_DECLARATION() [24/33]

maxon::MAXON_DECLARATION ( const maxon::DataType ,
DT_SourceLocation  ,
"net.maxon.datatype.sourcelocation"   
)

◆ PrivateGetDataType() [38/52]

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

◆ MAXON_ASSERT_LEGAL_LAYOUT() [1/10]

maxon::MAXON_ASSERT_LEGAL_LAYOUT ( SourceLocation  )

◆ PrivateDataTypeMarker() [21/29]

void* maxon::PrivateDataTypeMarker ( DelegateBase )

◆ MAXON_DECLARATION() [25/33]

maxon::MAXON_DECLARATION ( const maxon::DataType ,
DT_DelegateBase  ,
"net.maxon.datatype.delegatebase"   
)

◆ PrivateGetDataType() [39/52]

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

◆ MAXON_ASSERT_LEGAL_LAYOUT() [2/10]

maxon::MAXON_ASSERT_LEGAL_LAYOUT ( DelegateBase  )

◆ PrivateDataTypeMarker() [22/29]

void* maxon::PrivateDataTypeMarker ( AInt )

◆ MAXON_DECLARATION() [26/33]

maxon::MAXON_DECLARATION ( const maxon::DataType ,
DT_AInt  ,
"int"   
)

◆ PrivateGetDataType() [40/52]

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

◆ MAXON_ASSERT_LEGAL_LAYOUT() [3/10]

maxon::MAXON_ASSERT_LEGAL_LAYOUT ( AInt  )

◆ PrivateDataTypeMarker() [23/29]

void* maxon::PrivateDataTypeMarker ( AUInt )

◆ MAXON_DECLARATION() [27/33]

maxon::MAXON_DECLARATION ( const maxon::DataType ,
DT_AUInt  ,
"uint"   
)

◆ PrivateGetDataType() [41/52]

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

◆ MAXON_ASSERT_LEGAL_LAYOUT() [4/10]

maxon::MAXON_ASSERT_LEGAL_LAYOUT ( AUInt  )

◆ PrivateDataTypeMarker() [24/29]

void* maxon::PrivateDataTypeMarker ( AFloat )

◆ MAXON_DECLARATION() [28/33]

maxon::MAXON_DECLARATION ( const maxon::DataType ,
DT_AFloat  ,
"float"   
)

◆ PrivateGetDataType() [42/52]

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

◆ MAXON_ASSERT_LEGAL_LAYOUT() [5/10]

maxon::MAXON_ASSERT_LEGAL_LAYOUT ( AFloat  )

◆ PrivateGetEnumDataType()

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

◆ PrivateGetDataType() [43/52]

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

◆ PrivateGetDataType() [44/52]

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

◆ GetDataType()

const DataType * GetDataType ( )

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

Template Parameters
TType for which the DataType shall be obtained.
POLICYAn 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
TType of which the DataType representation shall be obtained.
POLICYOptional parameter to modify the data type resolution.
Returns
DataType for T.

◆ PrivateGetDataType() [45/52]

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

◆ PrivateDataTypeMarker() [25/29]

void* maxon::PrivateDataTypeMarker ( ConstDataPtr )

◆ MAXON_DECLARATION() [29/33]

maxon::MAXON_DECLARATION ( const maxon::DataType ,
DT_ConstDataPtr  ,
"net.maxon.datatype.constdataptr"   
)

◆ PrivateGetDataType() [46/52]

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

◆ MAXON_ASSERT_LEGAL_LAYOUT() [6/10]

maxon::MAXON_ASSERT_LEGAL_LAYOUT ( ConstDataPtr  )

◆ PrivateDataTypeMarker() [26/29]

void* maxon::PrivateDataTypeMarker ( DataPtr )

◆ MAXON_DECLARATION() [30/33]

maxon::MAXON_DECLARATION ( const maxon::DataType ,
DT_DataPtr  ,
"net.maxon.datatype.dataptr"   
)

◆ PrivateGetDataType() [47/52]

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

◆ MAXON_ASSERT_LEGAL_LAYOUT() [7/10]

maxon::MAXON_ASSERT_LEGAL_LAYOUT ( DataPtr  )

◆ PrivateDataTypeMarker() [27/29]

void* maxon::PrivateDataTypeMarker ( MoveDataPtr )

◆ MAXON_DECLARATION() [31/33]

maxon::MAXON_DECLARATION ( const maxon::DataType ,
DT_MoveDataPtr  ,
"net.maxon.datatype.movedataptr"   
)

◆ PrivateGetDataType() [48/52]

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

◆ MAXON_ASSERT_LEGAL_LAYOUT() [8/10]

maxon::MAXON_ASSERT_LEGAL_LAYOUT ( MoveDataPtr  )

◆ PrivateDataTypeMarker() [28/29]

void* maxon::PrivateDataTypeMarker ( ForwardingDataPtr )

◆ MAXON_DECLARATION() [32/33]

maxon::MAXON_DECLARATION ( const maxon::DataType ,
DT_ForwardingDataPtr  ,
"net.maxon.datatype.forwardingdataptr"   
)

◆ PrivateGetDataType() [49/52]

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

◆ MAXON_ASSERT_LEGAL_LAYOUT() [9/10]

maxon::MAXON_ASSERT_LEGAL_LAYOUT ( ForwardingDataPtr  )

◆ PrivateDataTypeMarker() [29/29]

void* maxon::PrivateDataTypeMarker ( Member )

◆ MAXON_DECLARATION() [33/33]

maxon::MAXON_DECLARATION ( const maxon::DataType ,
DT_Member  ,
"net.maxon.datatype.member"   
)

◆ PrivateGetDataType() [50/52]

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

◆ MAXON_ASSERT_LEGAL_LAYOUT() [10/10]

maxon::MAXON_ASSERT_LEGAL_LAYOUT ( Member  )

◆ PrivateGetDataType() [51/52]

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

◆ MAXON_ENUM_ORDERED_LIST() [1/2]

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

◆ PrivateGetDataType() [52/52]

Result<const 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_ASSERT_STANDARD_LAYOUT()

maxon::MAXON_ASSERT_STANDARD_LAYOUT ( DataType  )

◆ MAXON_ENUM_FLAGS() [2/2]

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

◆ 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() [2/2]

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

◆ 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]a1First value of first tuple.
[in]b1First value of second tuple.
[in]abThe 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]a1First value of first tuple.
[in]b1First value of second tuple.
[in]abThe 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]a1First value of first tuple.
[in]b1First value of second tuple.
[in]abThe remaining values of the tuples (in the order a2, b2, a3, b3, ...).
Returns
Lexicographic comparison of the tuples (a1, a2, ...), (b1, b2, ...).

◆ Compare() [1/3]

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

◆ MAXON_INTERFACE_NONVIRTUAL() [1/2]

MAXON_INTERFACE_NONVIRTUAL ( GradientInterface  ,
MAXON_REFERENCE_COPY_ON_WRITE  ,
"net.maxon.interface.gradient"   
)
private

◆ AllocAlphaGradient()

MAXON_METHOD Result<Gradient*> AllocAlphaGradient ( )

Allocates an alpha gradient.

Returns
The alpha gradient.

◆ GetAlphaGradient()

MAXON_METHOD Gradient* GetAlphaGradient ( )

Returns the internal alpha gradient.

Returns
The alpha gradient.

◆ GetKnotCount() [1/2]

MAXON_METHOD Int GetKnotCount ( ) const

Gets the number of knots.

Returns
The knot count.

◆ InsertKnot()

MAXON_METHOD Result<Int> InsertKnot ( const GradientKnot knot,
Bool  keepId = false 
)

Inserts a knot.

Parameters
[in]knotThe knot to insert.
[in]keepIdSpecifies if the knot ID should be taken from knot or if a new one should be generated.
Returns
The index of the inserted knot, GetKnotCount() - 1

◆ RemoveKnot()

MAXON_METHOD Result<void> RemoveKnot ( Int  index)

Removes a knot.

Parameters
[in]indexThe knot index. 0 <= index < GetKnotCount()
Returns
OK on success.

◆ GetKnot() [1/2]

MAXON_METHOD GradientKnot GetKnot ( Int  index) const

Gets the knot at index.

Parameters
[in]indexThe knot index. 0 <= index < GetKnotCount()
Returns
The knot.

◆ SetKnot()

MAXON_METHOD Result<void> SetKnot ( Int  index,
const GradientKnot k 
)

Sets knot at index.

Parameters
[in]indexThe knot index. 0 <= index < GetKnotCount()
[in]kThe knot.

◆ ConvertToAlphaGradient()

MAXON_METHOD void ConvertToAlphaGradient ( )

Converts the current gradient to an alpha gradient.

◆ SortKnots()

MAXON_METHOD void SortKnots ( )

Sorts the knots according to their position.

◆ InvertKnots()

MAXON_METHOD Result<Bool> InvertKnots ( )

Inverts the knots.

Returns
True if any knot inverted, otherwise false.

◆ DoubleKnots()

MAXON_METHOD Result<Bool> DoubleKnots ( )

Doubles the knots.

Returns
True if any knot doubled, otherwise false.

◆ DistributeKnots()

MAXON_METHOD Bool DistributeKnots ( )

Distributes the knots evenly.

Returns
True if any knot distributed, otherwise false.

◆ Flush()

MAXON_METHOD void Flush ( )

Flushes all the knots.

◆ SetIsAlphaGradient()

MAXON_METHOD void SetIsAlphaGradient ( Bool  alphaGradient)

Sets the alpha mode.

Parameters
[in]alphaGradientThe gradient alpha type.

◆ IsAlphaGradient()

MAXON_METHOD Bool IsAlphaGradient ( ) const

Checks if this is an alpha gradient.

Returns
True, if this is an alpha gradient.

◆ Compare() [2/3]

MAXON_METHOD COMPARERESULT Compare ( const GradientInterface arg2) const

Compares this with another BigInteger value.

Parameters
[in]arg2The other BigInteger value to compare with.
Returns
The comparison result.

◆ GetHashCode() [1/2]

MAXON_METHOD UInt GetHashCode ( ) const

Gets the hash code for the gradient.

Returns
The checksum.

◆ InitRender()

MAXON_METHOD Result<GradientRenderData> InitRender ( const TransformColorDelegate transformColorDelegate) const

Initializes the gradient for rendering.

Parameters
[in]transformColorDelegateA delegate to transform the color of a gradient knot.
Returns
The render data.

◆ MAXON_INTERFACE_NONVIRTUAL() [2/2]

MAXON_INTERFACE_NONVIRTUAL ( GradientRenderDataInterface  ,
MAXON_REFERENCE_COPY_ON_WRITE  ,
"net.maxon.interface.gradientrenderdata"   
)
private

◆ CalcGradientPixel()

MAXON_METHOD Color CalcGradientPixel ( Float  pos) const

Calculates a gradient pixel.

Parameters
[in]posThe X position.
Returns
The calculated gradient pixel.

◆ GetKnotCount() [2/2]

MAXON_METHOD Int GetKnotCount ( ) const

Gets the number of knots for GetRenderKnot().

Returns
The render knot count.

◆ GetKnot() [2/2]

MAXON_METHOD const GradientKnot* GetKnot ( Int  index) const

Gets a pointer to the knot at index.

Parameters
[in]indexThe knot index. 0 <= index < GetKnotCount()
Returns
The render knot at index. The gradient data owns the pointed knot.

◆ GetKnots()

MAXON_METHOD const BaseArray<GradientKnot>& GetKnots ( ) const

Gets a read only reference to internal knot list for fast access.

Returns
The knot list.

◆ Compare() [3/3]

MAXON_METHOD COMPARERESULT Compare ( const GradientRenderDataInterface arg2) const

Compares this with another GradientRenderData value.

Parameters
[in]arg2The other GradientRenderData value to compare with.
Returns
The comparison result.

◆ GetHashCode() [2/2]

MAXON_METHOD UInt GetHashCode ( ) const

Gets the checksum of the gradient render data.

Returns
The checksum of the gradient render data.

◆ DataDictionaryIterator() [1/2]

◆ GetOrDefault() [1/2]

IsFidClass<KEY>::type GetOrDefault ( KEY &&  key) const

◆ DataDictionaryIterator() [2/2]

◆ GetOrDefault() [2/2]

IsFidClass<KEY>::type GetOrDefault ( KEY &&  key) const

◆ AssertType()

void AssertType ( ) const

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
TType to compare.

◆ Is()

Bool Is ( ) const

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

Template Parameters
TType 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 ( ) const

Checks if a value of type T can be casted 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
TAnother data type.
Returns
True if a value of this data type can be safely casted from a value of type T.

◆ IsCastableTo()

Bool IsCastableTo ( ) const

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

See also
IsBaseOfOrSame.
Template Parameters
TAnother data type.
Returns
True if a value of this data type can be safely casted from a value of type T.

◆ Create()

Result< Data > Create ( )
static

Creates a Data and initializes it with the given type.

Template Parameters
TType 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]dataData to copy or move to this.

◆ InitSet() [2/2]

void InitSet ( Data &&  data)

◆ SetImpl()

Result< void > SetImpl ( T &&  data,
OverloadRank0   
)
private

◆ GetPtr() [1/2]

T * GetPtr ( void  )

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

Template Parameters
TThe desired type.
Returns
Pointer to the data in native format.

◆ GetPtr() [2/2]

Data* GetPtr ( void  )

◆ Set() [1/4]

void Set ( const T &  value)

◆ ToString() [2/2]

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

◆ Get() [1/3]

Result<void> Get ( void  ) 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)

◆ Get() [2/3]

Result<void> Get ( void  ) const

◆ Get() [3/3]

Result<Data> Get ( void  )

Variable Documentation

◆ Byte

enum Byte
strong

A byte.

◆ i [1/4]

Int32 i

◆ i [2/4]

Int32 i

◆ f [1/4]

◆ f [2/4]

◆ @1035

union { ... }

◆ i [3/4]

Int64 i

◆ i [4/4]

Int64 i

◆ f [3/4]

◆ f [4/4]

◆ @1037

union { ... }

◆ KEEP

const Bool KEEP
static

◆ InvalidArrayIndex

const Int InvalidArrayIndex
static

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

◆ MAXON_FLEXIBLE_ARRAY_LENGTH

const Int MAXON_FLEXIBLE_ARRAY_LENGTH
static

Use this as the bound of an array which is the last member of a class and shall have a flexible array length. Example:

struct MyStruct
{
Int a;
};
...
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 and copy operations properly. Keep in mind that the actual class instance may have less elements than the compiler thinks.

◆ DONT_INITIALIZE

const ENUM_DONT_INITIALIZE DONT_INITIALIZE
static

◆ IN_PLACE

const IN_PLACE_TYPE IN_PLACE
static

◆ TestForCopyFromFunction

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

◆ 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

struct maxon::GradientKnot MAXON_ENUM_ORDERED_LIST

◆ CUBICKNOT

CUBICKNOT

Cubic knot.

◆ SMOOTHKNOT

SMOOTHKNOT

Smooth knot.

◆ LINEARKNOT

LINEARKNOT

Linear knot.

◆ NONE

NONE

Step.

◆ EXP_UP

EXP_UP

Exponential up (legacy).

◆ EXP_DOWN

EXP_DOWN

Exponential down (legacy).

◆ BLEND

BLEND

Blend.

◆ col

Color col

Color.

◆ brightness

Float brightness

Brightness.

◆ pos

Float pos

Position.

◆ bias

Float bias

Bias.

◆ index

Int32 index

Knot ID in GradientInterface, knot index in GradientRenderDataInterface.

◆ interpolation

Friends

◆ operator== [1/2]

Bool operator== ( const IntFloat32 a,
const IntFloat32 b 
)
friend

◆ operator!= [1/2]

Bool operator!= ( const IntFloat32 a,
const IntFloat32 b 
)
friend

◆ operator== [2/2]

Bool operator== ( const IntFloat64 a,
const IntFloat64 b 
)
friend

◆ operator!= [2/2]

Bool operator!= ( const IntFloat64 a,
const IntFloat64 b 
)
friend