Namespaces | Classes | Typedefs | Enumerations | Functions | Variables
maxon Namespace Reference

Detailed Description

The maxon namespace contains all declarations of the MAXON API.

Useful apibasemath extensions.

Namespaces

 ANIMATION
 
 APPLICATIONID
 
 APPMESSAGE
 
 APPSETTINGS
 
 ARGUMENTS
 
 ASSET
 
 ASSETMETADATA
 
 ASSETREPOSITORYPROPERTIES
 
 AssetRepositoryTypes
 
 ASSETTYPEPROPERTIES
 
 AssetTypes
 
 ATTRIBUTE
 
 ATTRIBUTEMANAGER
 
 AutoWeightAlgos
 
 AutoWeightComponents
 
 BASE64_OPTIONS
 
 BlendFunctions
 
 BLOWFISHLEGACYENDECODER_OPTIONS
 
 CATEGORY
 
 Classes
 
 CodeExchangeLanguageId
 
 ColorProfiles
 
 ColorSpaces
 
 ColorTable
 
 COMMAND
 
 CommandClasses
 
 CommandDataClasses
 
 CONVEXDECOMPOSITIONATTRIBUTES
 
 ConvexDecompositionClasses
 
 corenodes
 
 CPythonLibs
 
 CryptographyOptions
 
 CustomDataTagClasses
 
 CustomDataTagDisplayClasses
 
 CUSTOMGUI_DATATYPE
 
 CustomNodeGui
 
 DATAFORMAT
 
 DATAFORMATBASEIDS
 
 DataFormatBaseReader
 
 DataFormatBaseWriter
 
 DataFormatReaderFactories
 
 DataFormatWriterFactories
 
 DATATYPE
 
 DESCRIPTION
 
 detail
 
 details
 
 Dimensions
 
 EXCHANGE
 
 EXIFDATA
 
 FFTClasses
 
 FileFormatHandlers
 
 FILEFORMATPROPERTIES
 
 FileFormats
 
 FilterClasses
 
 FilterCommandQueueClasses
 
 FilterContextClasses
 
 FilterImageClasses
 
 FilterImageDescriptionParameters
 
 HASH_HMAC
 
 HTTPANSWER
 
 HTTPREQUEST
 
 ImageBaseClasses
 
 IMAGEBASEPROPERTIES
 
 ImageChannelTypes
 
 ImageClasses
 
 ImageLayerClasses
 
 ImagePixelBlends
 
 ImagePixelBlendsInternal
 
 ImagePixelStorageClasses
 
 IMAGEPROPERTIES
 
 ImageSaverClasses
 
 ImageTextureClasses
 
 InterpolateTypes
 
 LegacyCommandDataClasses
 
 Loggers
 
 LOGGERTYPEFLAGS
 
 LoggerTypes
 
 MACHINE_MESSAGE
 
 MACHINEINFO
 
 material
 
 MATERIAL
 
 MEDIAFORMAT
 
 MEDIAINPUTPROPERTIES
 
 MEDIAOUTPUTURLPROPERTIES
 
 MEDIAPROPERTIES
 
 MEDIASESSION
 
 MEDIASTREAM
 
 MODULEVERSIONINFO
 
 NETWORK
 
 NETWORKWEBSOCKETCONNECTIONPROPERTIES
 
 NEUTRON
 
 neutron
 
 NODE
 
 nodes
 
 NODESPACE
 
 NOISEPROPERTY
 
 OBJECT
 
 OIDNFilterParameter
 
 ParametricTypes
 
 ParserClasses
 
 PARSERPARAMETERS
 
 PATTERN
 
 PixelFormats
 
 PresetAssetImplementations
 
 py
 
 py3
 
 PythonVms
 
 ReadArchiveClasses
 
 reflection
 
 RenderNoiseClasses
 
 rla
 
 specialtype
 
 SqlDatabaseClasses
 
 STREAMCONVERSION
 
 STREAMCONVERSIONFACTORYFLAGS
 
 StreamConversions
 
 STREAMCONVERSIONTEST
 
 STREAMFLAGS
 
 StringDecodings
 
 StringEncodings
 
 SubDataOperations
 
 SubDatas
 
 timezone
 
 TransactionProperties
 
 UiConversions
 
 Units
 
 URLFLAGS
 
 UTF8_OPTIONS
 
 UTFTEXT_OPTIONS
 
 VectorImageClasses
 
 VirtualMachines
 
 VmDebuggerConnections
 
 WriteArchiveClasses
 

Classes

struct  Bone
 
struct  AutoWeightPointJointSelections
 
class  AutoWeightInterface
 
class  CommandAssetInterface
 
struct  AssetDatabaseStruct
 
class  AssetDataBasesInterface
 
class  DragAndDropDataAssetArray
 
class  KeywordAssetInterface
 
class  AssetUtilitiesInterface
 
class  WatchFolderAssetRepositoryInterface
 
struct  AssetDependencyStruct
 
class  AssetMetaDataInterface
 
class  AssetTypeInterface
 
class  AssetIdentifierInterface
 
class  AssetLinkInterface
 
class  AssetRepositoryInterface
 
class  DerivedAssetRepositoryDataInterface
 
class  AssetBaseInterface
 
class  AssetDescriptionInterface
 
class  AssetBaseWithUpdateInterface
 
class  AssetReferenceInterface
 
class  AssetInterface
 
class  UpdatableAssetInterface
 
class  UpdatableAssetRepositoryInterface
 
class  CompactableAssetRepositoryInterface
 
class  FileAssetInterface
 
class  StoreAssetStruct
 
class  ResolveAssetDependenciesStruct
 
class  AddAssetDepencendyStruct
 
class  PresetLoadArgs
 
class  PresetSaveArgs
 
class  BasePresetAssetTypeInterface
 
class  BasePresetAssetInterface
 
class  CreatePresetAssetStruct
 
class  CategoryAssetInterface
 
class  ColorCategoryAssetInterface
 
class  DatabaseAssetInterface
 
class  DataDescriptionPresetStorageInterface
 
class  LazyLanguageStringDataDescriptionDefinitionInterface
 
class  LazyLanguageDictionaryInterface
 
class  NodeSpaceAssetInterface
 
class  PluginAssetInterface
 
class  SmartSearchAssetInterface
 
class  SubTypeAssetInterface
 
class  UrlAssetRepositoryInterface
 
class  PreviewImageData
 
class  PreviewImageCustomGui
 
class  BaseBitSet
 
class  AssetCreationInterface
 
class  AssetManagerInterface
 
class  RendererDefaultMaterialInterface
 
class  CustomNodeGuiBase
 
class  AttributeManagerProxyInterface
 
class  CustomNodeGuiProxyInterface
 
class  DescEntryStruct
 
class  DescTranslation
 
struct  NumToString
 
struct  NumToString< 0 >
 
class  PythonElementBaseInterface
 
class  PythonElementEmbeddedInterface
 
class  PythonElementScriptInterface
 
class  PythonBaseList2DDetectorInterface
 
class  PyElementManagerInterface
 
class  UiConversionInterface
 
class  CommandTuple
 
class  CommandDataInterface
 
class  LegacyCommandDataInterface
 
class  CommandClassInterface
 
class  CommandInteractionClassInterface
 
class  CommandDescriptionClassInterface
 
class  LegacyCommandClassInterface
 
class  MigratedCommandClassInterface
 
class  CommandConversionClassInterface
 
class  CommandCacheData
 
class  CommandCacheInterface
 
class  CommandExecutionInterface
 
class  NullValueFunctionsHelper< const Result< COMMANDRESULT > & >
 
struct  InvocationState
 
class  CommandObserverInterface
 
struct  ABIParamType
 
struct  ABIParamType< T, typename std::enable_if< STD_IS_REPLACEMENT(enum, T)||STD_IS_REPLACEMENT(integral, T)>::type >
 
struct  ABIParamType< Block< T, STRIDED, MOVE > >
 
struct  ABIParamType< T, typename std::enable_if< STD_IS_REPLACEMENT(pointer, T)>::type >
 
struct  ABIParamType< T, typename std::enable_if< STD_IS_REPLACEMENT(reference, T)>::type >
 
struct  IsIterable
 
struct  IsIterable< T[N]>
 
class  Match
 
class  Match< Int >
 
struct  PredicateMatcher
 
struct  ValuePredicate
 
struct  ValueComparePredicate
 
struct  RepeatingPredicateMatcher
 
struct  SequenceMatcher
 
struct  IntType
 
struct  IntType< 1 >
 
struct  IntType< 2 >
 
struct  IntType< 4 >
 
struct  IntType< 8 >
 
struct  UIntType
 
struct  UIntType< 1 >
 
struct  UIntType< 2 >
 
struct  UIntType< 4 >
 
struct  UIntType< 8 >
 
struct  StandardType
 
struct  StandardType< T, true >
 
class  Block
 
class  GenericComponent
 
class  Result
 
class  ResultOk
 
class  EmptyClass
 
class  EmptyVirtualClass
 
class  SFINAEHelper
 
class  PrivateOverloadRank0
 
class  PrivateOverloadRank1
 
class  PrivateOverloadRank2
 
class  PrivateOverloadRank3
 
class  PrivateOverloadRank4
 
class  PrivateOverloadRank5
 
struct  AlwaysFalse
 
struct  And
 
struct  And< true, REST... >
 
struct  And< false, REST... >
 
struct  And<>
 
class  Protected
 
class  ConstIf
 
class  ConstIf< T, true >
 
class  InheritConst
 
class  InheritConst< T, const INHERIT_FROM >
 
class  Substitute
 
class  Substitute< T &, R >
 
class  Substitute< T &&, R >
 
struct  ParameterPack
 
struct  ParameterPack< T, REST... >
 
struct  GetSignature
 
struct  GetSignature< RET(ARGS...)>
 
struct  GetSignature< RET(*)(ARGS...)>
 
struct  GetSignature< RET(CALLABLE::*)(ARGS...)>
 
struct  GetSignature< RET(CALLABLE::*)(ARGS...) const >
 
class  CommonLValue
 
class  CommonType
 
struct  MemberDetectorHelper
 
class  EnableIfFlag
 
class  IsCompleteBase
 
class  IsComplete
 
struct  GetReferencedType
 
struct  GetReferencedType< T, DEF, typename maxon::SFINAEHelper< void, typename std::decay< T >::type::ReferencedType >::type >
 
struct  GetConstReferencedType
 
struct  GetConstReferencedType< T, DEF, typename maxon::SFINAEHelper< void, typename std::decay< T >::type::ConstReferencedType >::type >
 
struct  GetDirectlyReferencedType
 
struct  GetDirectlyReferencedType< T, DEF, typename maxon::SFINAEHelper< void, typename std::decay< T >::type::DirectlyReferencedType >::type >
 
struct  GetErasedType
 
struct  GetErasedType< T, DEF, typename maxon::SFINAEHelper< void, typename std::decay< T >::type::ErasedType >::type >
 
struct  GetDirectlyReferencedTypeCheckConstAndPtr
 
struct  IsAllocType
 
struct  IsAllocType< T, DEF, typename maxon::SFINAEHelper< void, typename std::decay< T >::type::IsAllocType >::type >
 
struct  IsNonvirtualInterfaceType
 
struct  IsNonvirtualInterfaceType< T, DEF, typename maxon::SFINAEHelper< void, typename std::decay< T >::type::NonvirtualInterfaceMarker >::type >
 
struct  IsVirtualInterfaceType
 
struct  IsVirtualInterfaceType< T, DEF, typename maxon::SFINAEHelper< void, typename std::decay< T >::type::InterfaceMarker >::type >
 
struct  IsInterfaceType
 
struct  IsInterfaceType< T, DEF, typename maxon::SFINAEHelper< void, typename std::decay< T >::type::MTable >::type >
 
struct  GetValueType
 
struct  GetValueType< T, DEF, typename maxon::SFINAEHelper< void, typename std::decay< T >::type::ValueType >::type >
 
struct  CheckHasBase
 
struct  CheckHasBase< T, DEF, typename maxon::SFINAEHelper< void, typename std::decay< T >::type::HasBaseDetector >::type >
 
struct  GetNonConst
 
struct  GetNonConst< T, DEF, typename maxon::SFINAEHelper< void, typename std::decay< T >::type::NonConst >::type >
 
struct  GetHandler
 
struct  GetHandler< T, DEF, typename maxon::SFINAEHelper< void, typename std::decay< T >::type::Handler >::type >
 
class  IsReferenceClass
 
class  IsObjectReferenceClass
 
struct  IsPartiallyOrdered
 
struct  IsPartiallyOrdered< T, DEF, typename maxon::SFINAEHelper< void, typename std::decay< T >::type::PartiallyOrdered >::type >
 
struct  IsTriviallyEquatable
 
struct  IsTriviallyHashable
 
struct  IsTriviallyHashable< T, decltype(T::TriviallyHashable())>
 
struct  IsZeroInitialized
 
struct  IsZeroInitialized< Generic >
 
struct  HasBaseDetector
 
struct  IsDerived
 
struct  HasErasedBase
 
struct  GenericCastMemberTrait
 
struct  GenericCastMemberTrait< const TO &, FROM, SAFE >
 
struct  GenericCastMemberTrait< const TO &, FROM &, SAFE >
 
struct  GenericCastMemberTrait< TO &, FROM &, SAFE >
 
struct  GenericCastMemberTrait< const TO *, FROM *, SAFE >
 
struct  GenericCastMemberTrait< TO *, FROM *, SAFE >
 
struct  GenericCastTrait
 
class  ByValueParam
 
class  MultiplicativePromotion
 
class  MultiplicativePromotion< T1, T2, false >
 
class  MultiplicativePromotion< GenericArithmetic, T, true >
 
class  MultiplicativePromotion< T, GenericArithmetic, true >
 
class  MultiplicativePromotion< GenericArithmetic, GenericArithmetic, true >
 
class  Dereference
 
class  BaseRef
 
class  Dereference< BaseRef< T, HANDLER >, false >
 
class  ForEach
 
class  UnitType
 
class  GenericArithmetic
 
class  ThreadReferencedError
 
struct  ValueKindHelper
 
struct  ValueKindHelper< T *, REF >
 
struct  ValueKindHelper< T, true >
 
struct  ValueKindHelper< ObjectInterface, false >
 
class  GetCollectionKind
 
struct  TestForCopyFromMember
 
class  ObjectConstructor
 
class  ObjectConstructor< T, false >
 
struct  HasInit
 
struct  AlignedStorage
 
class  DefaultLValue
 
class  Application
 
class  PersistentIdGeneratorInterface
 
class  StaticArrayInterface
 
class  NonConstArray
 
class  ArrayInterface
 
class  ArrayFactory
 
class  ArrayCloneHelper
 
class  ArrayImpl
 
class  ArrayCloneHelper< ARRAY & >
 
class  ArrayAllocator
 
struct  ArrayAllocatorValueType
 
class  BlockArrayAllocator
 
class  BaseArrayAllocator
 
class  BufferedBaseArrayAllocator
 
class  ArrayMapHelper
 
class  ArrayMapHelper< K, V, true, COMPARE, ARRAY >
 
class  ArrayMap
 
class  ArrayMapSelector
 
class  ArraySet
 
class  ARWLock
 
class  ScopedARWReadLock
 
class  ScopedARWWriteLock
 
class  Atomic32
 
class  Atomic64
 
class  Atomic16
 
class  Atomic8
 
class  AtomicBool
 
class  AtomicFloatType
 
class  AtomicPtr
 
class  StrongReferenceCounter
 
class  BackgroundEntryInterface
 
class  BackgroundProgressInterface
 
class  BaseArray
 
struct  GenericCastMemberTrait< BaseArray< TO >, BaseArray< FROM >, SAFE >
 
class  BaseArraySelector
 
class  BufferedBaseArraySelector
 
struct  IsZeroInitialized< BaseArray< T, MINCHUNKSIZE, MEMFLAGS, ALLOCATOR > >
 
struct  BaseListLinkPOD
 
class  BaseListLink
 
class  BaseListNodeBase
 
class  BaseListNode
 
class  BaseListNode< T, false >
 
class  BaseListNode< T, true >
 
class  BaseListNode< EmptyClass, false >
 
class  BaseListHead
 
class  BaseList
 
class  BaseListLegacyNode
 
class  WeakRef
 
class  PointerHandler
 
class  StrongRefHandler
 
class  StrongCOWRefHandler
 
class  StrongACOWRefHandler
 
class  UniqueRefHandler
 
struct  RawMem
 
class  BaseRef< RawMem< T >, H >
 
class  BlockBase
 
class  BlockBase< T, false >
 
class  BaseIterator
 
class  BaseIterator< COLLECTION, true >
 
struct  CArray
 
class  BlockArray
 
class  BlockArraySelector
 
class  BlockBufferAllocator
 
class  PointerBurstTriePool
 
class  ElementPool
 
class  ArrayBurstTriePool
 
struct  BurstTrieNode
 
struct  BurstTrieBucket
 
struct  BurstTrieBucket< K, UnitType, SIZE >
 
class  BurstTrieMap
 
class  BurstTrieMapSelector
 
class  BurstTrieSet
 
class  BytesValue
 
class  Bytes
 
class  Kilobytes
 
class  Kibibytes
 
class  Mebibytes
 
class  Megabytes
 
class  Gibibytes
 
class  Gigabytes
 
class  Terabytes
 
class  Tebibytes
 
class  PrivateGetMapKeyHelper
 
class  PrivateGetMapKey
 
class  GetCollectionKind< COLLECTION, typename SFINAEHelper< void, typename std::decay< COLLECTION >::type::IsCollection >::type >
 
class  BaseCollection
 
class  Collection
 
class  BlockIterator
 
class  ArrayBase0
 
class  ArrayBase
 
class  SetBase0
 
class  SetImpl
 
class  SetBase
 
class  MapBase0
 
class  MapImpl
 
class  MapBase
 
class  ConditionVariableInterface
 
class  Configuration
 
struct  ContainerVariance
 
struct  ContainerVariance< TO, FROM, 0 >
 
class  GenericContainerInterface
 
class  GenericIndexableContainerInterface
 
class  RecursiveContainer
 
class  ContiguousRangeMap
 
class  CpuYieldState
 
class  CpuYield
 
class  CrashHandler
 
struct  CrashCallStackEntry
 
struct  GenericRegisterValue
 
struct  CrashRegisterValue
 
struct  CrashThreadState
 
struct  CrashModuleEntry
 
struct  CrashReportState
 
class  CrashLogKey
 
class  CrashHandlerGlobals
 
struct  CrashReportPropertyItem
 
class  CrashReportProperty
 
class  CrashReportServices
 
class  Crc32C
 
class  CStdLibAllocator
 
class  CustomAllocatorInterface
 
class  CustomSTLAllocator
 
class  DataDescriptionInterface
 
class  SubMenuEntry
 
class  DataDescriptionUIInterface
 
class  DataDescriptionDatabaseInterface
 
class  DataDescriptionDefinitionInterface
 
class  DataDescriptionDefinitionDatabaseInterface
 
class  DataDescriptionDefinitionDatabaseImplInterface
 
class  DataDescriptionObjectInterface
 
class  Array
 
class  DataDictionaryInterface
 
class  DataDictionaryIteratorInterface
 
class  DataDictionaryIterator
 
struct  DataDictionaryKeySet
 
class  DataDictionaryObjectInterface
 
class  DataDictionaryReferenceObjectInterface
 
class  DataFormatReaderInterface
 
class  DataFormatWriterInterface
 
class  DataFormatBaseReaderInterface
 
class  DataFormatBaseWriterInterface
 
class  WriterRef
 
class  WriterRef< Utf32Char >
 
class  ReaderRef
 
class  ReaderRef< Utf32Char >
 
struct  IDENT_VOID
 
class  DESCRIBEFLAGS
 
class  DataSerializeInterface
 
class  DataSerializeWriterInterface
 
class  DataSerializeReaderInterface
 
class  UnregisteredDataTypeErrorInterface
 
struct  IsSimdElementType
 
struct  IsSimdElementType< T, typename SFINAEHelper< void, typename T::VectorStrideType >::type >
 
struct  SimdInfo
 
class  SimdBlock
 
struct  AInt
 
struct  AUInt
 
struct  AFloat
 
struct  CheckedGetDataType
 
class  DataTypeCache
 
class  DataTypeCacheInstance
 
class  DataTypeCacheInstance< T, POLICY, true >
 
class  DataTypeCacheInstance< void, POLICY, true >
 
class  DataTypeCacheInstance< std::nullptr_t, POLICY, true >
 
class  DataTypeCacheInstance< InvalidType, POLICY, true >
 
struct  NamedTupleMembers
 
class  NamedTuple
 
class  TupleValue
 
class  FunctionDataType
 
struct  CheckedGetDataType< T, POLICY, false >
 
struct  DataTypeComponent
 
class  DataTypeBuilderInterface
 
class  DataTypeBuilderEntry
 
struct  DataMemBlock
 
class  Opt
 
class  DataTypePtr
 
class  DataTypeImpl
 
class  DataType
 
class  Data
 
struct  IsZeroInitialized< Data >
 
class  ConstDataPtr
 
class  DataPtr
 
class  MoveDataPtr
 
struct  ForwardingDataPtr
 
class  TrivialDataPtr
 
class  AbstractDataTypeFunctions
 
class  DataTypeReferenceFunctions
 
class  DefaultDataTypeFunctionsBase
 
class  DefaultDataTypeFunctions
 
class  DefaultDataTypeFunctions< T, DATATYPEMODE::SMALLISPOD >
 
class  DefaultDataTypeFunctions< T, DATATYPEMODE::SMALL >
 
class  DefaultDataTypeFunctions< T, DATATYPEMODE::BIG >
 
struct  DefaultDataTypeFunctionsCapabilityFlags
 
class  DataTypeFunctions
 
class  InterfaceDataTypeFunctions
 
class  InternedId
 
struct  IsTriviallyEquatable< InternedId >
 
struct  IsZeroInitialized< InternedId >
 
struct  Member
 
struct  TypeArguments
 
class  DataTypeLib
 
class  TupleDataType
 
class  DelegateDataType
 
class  EnumDataType
 
class  ContainerDataType
 
class  LocalDateTime
 
class  UniversalDateTime
 
class  DebugHardwareBreakPointInterface
 
class  Debugger
 
class  DecoratorInterface
 
class  EagerDecoratorInterface
 
class  WeakDecoratorInterface
 
class  DefaultAllocator
 
struct  IsZeroInitialized< DefaultAllocator >
 
class  DelegateBase
 
class  Delegate
 
class  Delegate< RESULT(ARGS...)>
 
struct  GenericCastMemberTrait< ParameterPack< TO, TO_REST... >, ParameterPack< FROM, FROM_REST... >, SAFE >
 
struct  GenericCastMemberTrait< Delegate< RESULT_TO(ARGS_TO...)>, Delegate< RESULT_FROM(ARGS_FROM...)>, SAFE >
 
class  DescriptionMessageCallbackInterface
 
class  DescriptionProcessorInterface
 
class  DllInterface
 
class  OutOfMemoryErrorInterface
 
class  FunctionNotImplementedErrorInterface
 
class  IllegalArgumentErrorInterface
 
class  NullptrErrorInterface
 
class  IllegalStateErrorInterface
 
class  UnexpectedErrorInterface
 
class  OperationCancelledErrorInterface
 
class  AggregatedErrorInterface
 
class  AggregatedError
 
class  ErrorIndirectRef
 
class  ErrorPtr
 
class  NoErrorPtr
 
class  UnsupportedArgumentErrorInterface
 
class  UnresolvedErrorInterface
 
class  UnknownErrorInterface
 
class  UnsupportedOperationErrorInterface
 
class  ShutdownErrorInterface
 
class  DisabledErrorInterface
 
class  ErrnoErrorInterface
 
class  FactoryInterface
 
class  FactoryFunctions< Factory< T(ARGS...)>, SUPER >
 
class  FactoryFunctions< Factory< T(const DataDictionary &)>, SUPER >
 
class  Factory< T(ARGS...)>
 
class  FactoryFactory
 
class  FId
 
class  FId< T, InternedId >
 
class  PrivateGetFIdKeyType
 
class  PrivateGetFIdKeyType< const char(&)[N]>
 
class  RESTRICT
 
class  FileUtilities
 
class  FileFormatInterface
 
class  FileFormatDetectionCacheInterface
 
class  FileFormatHandlerInterface
 
class  FileFormatDetectionInterface
 
struct  FixedBufferMemory
 
struct  FixedBufferMemory< SIZE, PARENT_ALLOCATOR, false >
 
class  FixedBufferAllocatorBase
 
class  FixedBufferAllocator
 
class  FixedSizeBitSet
 
struct  FlexibleArray
 
class  Misc
 
class  SuppressFloatingPointChecks
 
struct  GetIteratorType
 
struct  GetIteratorType< T[N]>
 
class  ReverseIterator
 
class  ForEachIterator
 
class  AutoIterator
 
class  AutoIterator< T[N]>
 
class  NestedForEachIterator
 
class  CommonIteratorTypes
 
class  CommonIteratorTypes< void, I1, I2 >
 
class  ConcatForEachIterator
 
class  ConditionalForEachIterator
 
class  MapForEachIterator
 
class  FilterForEachIterator
 
class  ZipForEachIterator
 
class  IndexForEachIterator
 
class  SingletonForEachIterator
 
class  EraseIterator
 
class  EraseIterator< COLLECTION, SWAP_ERASE, false >
 
class  Iterable
 
class  ForwardRef
 
class  IsObjectReferenceClass< ForwardRef< T > >
 
class  IsObjectReferenceClass< ForwardRef< T > & >
 
class  IsObjectReferenceClass< ForwardRef< T > && >
 
class  IsObjectReferenceClass< const ForwardRef< T > & >
 
class  ForwardRefWithExtraBase
 
class  GenericBaseArray
 
class  GenericData
 
class  GetExtraDataCallbackInterface
 
class  HashBitSet
 
struct  DefaultHashMapEntryHandlerBase
 
struct  HashMapKeyValuePair
 
struct  HashMapValueKeyPair
 
struct  HashMapKeyHashValuePair
 
class  HashMapEntryBase
 
class  HashMapEntryBase< K, V, ENTRY_HANDLER, HASHMAP_ENTRY_LAYOUT::HASH_KEY_VALUE >
 
class  HashMapEntryBase< K, V, ENTRY_HANDLER, HASHMAP_ENTRY_LAYOUT::KEY_VALUE >
 
class  HashMapEntryBase< K, V, ENTRY_HANDLER, HASHMAP_ENTRY_LAYOUT::VALUE >
 
class  HashMapEntryBase< K, V, ENTRY_HANDLER, HASHMAP_ENTRY_LAYOUT::KEY_HASH_VALUE >
 
class  HashMapEntryBase< K, V, ENTRY_HANDLER, HASHMAP_ENTRY_LAYOUT::HASH_VALUE_KEY >
 
class  HashMapEntryBase< K, UnitType, ENTRY_HANDLER, HASHMAP_ENTRY_LAYOUT::HASH_KEY_VALUE >
 
class  HashMapEntryBase< K, UnitType, ENTRY_HANDLER, HASHMAP_ENTRY_LAYOUT::KEY_HASH_VALUE >
 
class  HashMapEntryBase< K, UnitType, ENTRY_HANDLER, HASHMAP_ENTRY_LAYOUT::HASH_VALUE_KEY >
 
class  HashMapEntryBase< K, UnitType, ENTRY_HANDLER, HASHMAP_ENTRY_LAYOUT::KEY_VALUE >
 
class  HashMap
 
class  HashMapSelector
 
struct  GenericCastMemberTrait< HashMap< K_TO, V_TO >, HashMap< K_FROM, V_FROM >, SAFE >
 
class  HashSet
 
struct  GenericCastMemberTrait< HashSet< TO >, HashSet< FROM >, SAFE >
 
class  HashMapStatistics
 
class  HierarchyIterator
 
struct  DefaultHierarchy
 
class  HierarchyObjectRef
 
struct  DefaultHierarchy< void >
 
class  HierarchyObjectIterator
 
class  HierarchyObjectInterface
 
class  HybridMapGetIteratorHelper
 
class  HybridMap
 
class  HybridMapSelector
 
class  HybridSet
 
class  IndexIteratorDefaultAccess
 
class  IndexIterator
 
class  UInteger
 
class  UInteger< SIZEOF(UIntegerBase) *8 >
 
class  PrivateDummyFree
 
struct  ClassInfoBase
 
struct  GenericCastMemberTrait< TO, FROM, SAFE, typename SFINAEHelper< void, typename TO::DirectlyReferencedType, typename FROM::DirectlyReferencedType >::type >
 
struct  IntFloat32
 
struct  IntFloat64
 
class  ReadArchiveInterface
 
class  WriteArchiveInterface
 
class  IoBrowseInterface
 
class  ResolveInterface
 
class  IoConnectionInterface
 
class  IoHandlerInterface
 
class  IoMemoryInterface
 
class  IoDualInOutputStreamInterface
 
class  IoPipeInOutputStreamInterface
 
class  UrlOrStream
 
class  IoErrorInterface
 
class  FileFormatErrorInterface
 
class  UnknownFileSizeErrorInterface
 
class  BaseStreamInterface
 
class  InputStreamInterface
 
class  OutputStreamInterface
 
class  InOutputStreamInterface
 
class  JobInterface
 
class  JobStatusInterface
 
class  JobStatusRef
 
class  JobResultInterface
 
class  JobResultInterface< Result< RESULTVALUETYPE > >
 
class  JobResultInterface< Result< void > >
 
class  JobResultInterface< void >
 
class  JobResultRef
 
class  JobInterfaceTemplate
 
struct  ResultMemJob
 
class  JobRef
 
class  JobResultRef< Result< RESULTVALUETYPE > >
 
class  PromiseRef
 
class  Promise
 
class  JobGroupInterface
 
class  JobGroupRef
 
class  StaticJobArray
 
class  StaticJobGroupInterface
 
class  StaticJobGroupRef
 
class  JobQueueInterface
 
class  ServiceIOJobQueueInterface
 
class  SerialJobQueueInterface
 
class  JobQueueRef
 
class  ServiceIOJobQueueRef
 
class  SerialJobQueueRef
 
class  LazyInit
 
class  LazyInitThreaded
 
struct  LegacyHash
 
class  LexerInterface
 
class  LinearCongruentialRandom
 
class  PseudoRandom
 
struct  LoggerLine
 
class  LoggerTypeInterface
 
class  FileLoggerTypeInterface
 
class  UserLoggerTypeInterface
 
class  LoggerInterface
 
class  MachineInterface
 
class  MachinesInterface
 
class  NonConstMap
 
class  MapInterface
 
class  MapCloneHelper
 
class  MapCloneHelper< MAP & >
 
struct  Col3
 
struct  IsZeroInitialized< Col3< T, 1 > >
 
struct  Col4
 
struct  Vec3
 
struct  IsZeroInitialized< Vec3< T, 1 > >
 
struct  Vec2
 
struct  IsZeroInitialized< Vec2< T, 1, SPACE > >
 
struct  Vec4
 
struct  IsZeroInitialized< Vec4< T, 1 > >
 
struct  SqrMat3
 
struct  Mat3
 
struct  SqrMat2
 
struct  Mat2
 
struct  SqrMat4
 
class  InternedIdInitializer
 
class  ModuleVersionInfoInterface
 
class  MultiIndexBuilder
 
class  MultiIndex
 
class  NullAllocator
 
struct  DefaultNullValue
 
class  NullValueFunctions
 
class  NullValueDetector
 
class  NullValueZeroInitializedHelper
 
class  NullValueZeroInitializedHelper< T & >
 
class  NullValueZeroInitializedHelper< const T & >
 
class  NullValueTypeHelper
 
class  NullValueTypeHelper< T & >
 
class  NullValueTypeHelper< const T & >
 
class  NullValueFunctionsHelper
 
class  NullValueFunctionsHelper< T & >
 
class  NullValueFunctionsHelper< const T & >
 
class  NullValueFunctions< Result< T > >
 
class  ComponentDescriptor
 
class  IsComplete< Class< T >, COUNTER >
 
class  Class
 
class  ClassInterface
 
class  ObjectInterface
 
class  ErrorInterface
 
class  AdapterRoot
 
class  ComponentHelper
 
struct  PrivateSelfHelperBase
 
struct  PrivateSelfHelper
 
class  ComponentHelper< BASE >
 
class  ComponentHelper< BASE, I, REST... >
 
struct  InterfacesBlock
 
class  ComponentWithBase
 
struct  Undefined
 
class  FunctionBaseInterface
 
class  CombinerInterface
 
class  ObservableBaseInterface
 
class  ObservableNotifyRef
 
class  ObservableNotifyRef< Delegate< RESULT(void)> >
 
class  ObservableNotifyRef< Delegate< RESULT(ARGS...)> >
 
class  ObservableRef
 
class  ObservableStaticInterface
 
class  ObservableImplRef
 
class  ObserverObjectInterface
 
class  StaticObservableStorage
 
class  OpaqueBase
 
class  Opt< T & >
 
class  Opt< const T & >
 
class  Opt< T && >
 
class  ParallelFor
 
class  ParallelImage
 
class  MoveHelper
 
class  MoveHelper< SOURCEITERATOR, DESTITERATOR, CONTENT, true, true >
 
class  MoveHelper< SOURCEITERATOR, DESTITERATOR, CONTENT, true, false >
 
class  MoveHelper< SOURCEITERATOR, DESTITERATOR, CONTENT, false, false >
 
class  MoveHelper< SOURCEITERATOR, DESTITERATOR, CONTENT, false, true >
 
class  MergeSegment
 
class  ParallelSort
 
class  SimpleParallelSort
 
class  ParametricTypeInterface
 
class  ParametricTypeDecorator
 
class  ParserInterface
 
class  MaximalElements
 
class  PointerArray
 
class  ProgressInterface
 
class  Queue
 
class  Range
 
struct  IsZeroInitialized< Range< T > >
 
class  RangeMap
 
class  RangeSet
 
class  RefCountHashMapDefaultHandler
 
class  RefCountHashMap
 
class  SetUsedFrameworks
 
class  SetExpectedModuleDependencies
 
class  Registry
 
class  RegistryDefinition
 
class  RunLoop
 
class  SecureRandom
 
struct  AppendToIndexSequence
 
struct  AppendToIndexSequence< std::index_sequence< SEQ... >, VALUE >
 
struct  SequenceElement
 
struct  SequenceElement< T, 0, VALUE, REST... >
 
struct  IndexSequenceElement
 
struct  IndexSequenceElement< std::index_sequence< VALUES... >, INDEX >
 
struct  GetSequenceElement
 
struct  GetSequenceElement< T, V0 >
 
struct  GetSequenceElement< T, V0, V1 >
 
struct  GetIndexSequenceElement
 
struct  GetIndexSequenceElement< std::index_sequence< VALUES... > >
 
struct  IndexInIndexSequence
 
struct  IndexInIndexSequence< I, std::index_sequence< X, LIST... > >
 
struct  Serializer
 
class  NonConstSet
 
class  SetInterface
 
class  SetCloneHelper
 
class  SetCloneHelper< SET & >
 
class  SettingsInterface
 
class  HelperClass
 
class  BaseSort
 
class  SimpleSort
 
class  HelperClass< SORTCLASS, ITERATOR, CONTENT, BASESORTFLAGS::NONE >
 
class  HelperClass< SORTCLASS, ITERATOR, CONTENT, BASESORTFLAGS::MOVEANDCOPYOBJECTS >
 
class  SortedArray
 
class  DefaultSortedArray
 
struct  Spinlock
 
struct  RWSpinlock
 
class  ScopedLock
 
class  ScopedLockPair
 
class  ScopedReadLock
 
class  ScopedWriteLock
 
class  Matrix4f32
 
class  Matrix4f64
 
class  Matrix4f64SSE
 
class  Vector2f64
 
class  Vector4f32
 
class  Vector4f64
 
class  Vector4i32
 
class  Vector8f32
 
class  Vector8i32
 
class  StackBufferAllocator
 
class  StackTrace
 
class  StreamConversionInterface
 
struct  ConversionTestSet
 
class  ArrayAppendCache
 
class  StringPosition
 
class  StringEnd
 
class  StringCount
 
class  StringTemplate
 
class  SysCharArray
 
class  StringInterface
 
class  CStringInterface
 
class  String
 
class  CString
 
class  ToStringHelper2
 
class  ToStringHelper2< T, false >
 
class  ToStringHelper2< T, true >
 
class  StringProxy
 
class  FormatStatement
 
class  StringConversion
 
class  StringEncodingInterface
 
class  StringDecodingInterface
 
class  LanguageInterface
 
class  Resource
 
class  SymbolificationInterface
 
struct  LockTraits
 
struct  LockTraits< Spinlock >
 
class  SynchronizedValue
 
class  System
 
class  SystemProcessKilledErrorInterface
 
class  SystemProcessOperationErrorInterface
 
class  SystemProcessObjectInterface
 
class  SystemProcessInterface
 
class  SystemErrorInterface
 
class  NSSystemErrorInterface
 
class  TaggedBaseRef
 
class  ThreadInterface
 
class  ThreadResultRef
 
class  ThreadInterfaceTemplate
 
class  ThreadRefTemplate
 
class  ThreadResultRef< Result< RESULTVALUETYPE > >
 
class  ThreadLocalPointer
 
class  ThreadLocalDestructiblePointer
 
class  ThreadSafePtr
 
class  ThreadSafeRef
 
class  JobErrorInterface
 
class  TimerInterface
 
class  TimeValue
 
class  Hours
 
class  Minutes
 
class  Seconds
 
class  Milliseconds
 
class  Microseconds
 
class  Nanoseconds
 
struct  IsZeroInitialized< TimeValue >
 
class  TreeMapParent
 
class  TreeMapParent< PARENT, true >
 
class  TreeMap
 
class  Tuple
 
struct  FindUniqueTupleIndex
 
struct  FindUniqueTupleIndex< SEARCHTYPE, Tuple< TYPES... > >
 
class  Tuple<>
 
class  IgnoredPlaceholder
 
struct  TupleElementEquals
 
struct  TupleElementLessThan
 
struct  TupleElementCompare
 
class  UnicodeUtils
 
class  DimensionInterface
 
class  UnitInterface
 
class  UrlInterface
 
class  Url
 
class  UrlFileCacheEntryInterface
 
class  UrlFileCacheInterface
 
class  RefCountedCString
 
class  ResultMemT
 
class  LiteralId
 
class  Id
 
class  LIMIT
 
class  LIMIT< Bool >
 
class  LIMIT< Int64 >
 
class  LIMIT< UInt64 >
 
class  LIMIT< Int32 >
 
class  LIMIT< UInt32 >
 
class  LIMIT< Int16 >
 
class  LIMIT< UInt16 >
 
class  LIMIT< Char >
 
class  LIMIT< UChar >
 
class  LIMIT< Float32 >
 
class  LIMIT< Float64 >
 
struct  Sum
 
struct  Sum< X, Y... >
 
struct  Sum<>
 
struct  Or
 
struct  Or< T, X, Y... >
 
struct  Or< T >
 
struct  TemplateInstantiation
 
struct  SubstituteType
 
struct  SubstituteType< T &, MAP, void >
 
struct  SubstituteType< T *, MAP, void >
 
struct  SubstituteType< const T, MAP, void >
 
struct  SubstituteType< T, MAP, typename SFINAEHelper< void, typename T::Instantiation >::type >
 
class  CompareTemplate
 
class  DefaultCompare
 
class  EqualityCompare
 
class  CStringCompare
 
class  RefCompare
 
class  RefCompare< true, false >
 
class  RefCompare< true, true >
 
class  RenameList
 
struct  IncludeHelper
 
class  FormatTemplateHelper
 
class  FormatTemplateHelper< ARGCNT, const Char(&)[N]>
 
class  DefaultDoc
 
class  DefaultHasher
 
class  FNV1aHasher
 
struct  UniqueHash
 
class  UniqueHasher
 
class  IoFileOutputHelper
 
class  IoFileInputHelper
 
struct  JavaCall
 
struct  JavaMember
 
struct  JavaClass
 
class  JavaClassArray
 
class  JavaClassHash
 
class  JavaHelper
 
class  LockedResourceHelper
 
class  LockedResourceMap
 
class  LRUHashMap
 
class  SourceLocation
 
class  CopyWrapper
 
class  ResultOk< T & >
 
class  ResultOk< void >
 
class  ResultRef
 
struct  ForwardResultPtr
 
class  ResultBase
 
class  ResultBase< T & >
 
class  ResultBase< void >
 
class  PrivateIsErrorClassHelper
 
class  PrivateIsErrorClassHelper< T, true >
 
class  IsErrorClass
 
class  IsErrorClass< ForwardRef< T > >
 
class  ResultSuper
 
class  ResultSuper< RESULT_TYPE, typename SFINAEHelper< void, typename RESULT_TYPE::template ResultFunctions< ResultBase< RESULT_TYPE > > >::type >
 
class  ResultSuper< RESULT_TYPE &, typename SFINAEHelper< void, typename RESULT_TYPE::template ResultFunctions< ResultBase< RESULT_TYPE & > > >::type >
 
struct  RemoveResult
 
struct  RemoveResult< Result< T > >
 
struct  RemoveResult< ResultOk< T > >
 
struct  GenericCastMemberTrait< Result< TO >, Result< FROM >, SAFE >
 
struct  GenericCastTrait< Result< TO >, FROM, SAFE >
 
struct  GenericCastTrait< Result< TO >, Result< FROM >, SAFE >
 
class  ResultIteratorFunctions
 
struct  ReuseData
 
class  ReuseResourceTemplate
 
class  RingBuffer
 
class  StreamConversionHelper
 
class  CollectorThread
 
class  ThreadedUIUpdateBase
 
class  ThreadedUIUpdate
 
class  ThreadedUIUpdateRef
 
class  UuidInterface
 
class  Uuid
 
class  ValueChangedCallbackInterface
 
class  HasValueReceiver
 
class  FirstValueReceiver
 
class  UniqueValueReceiver
 
struct  ViewIteratorMember
 
struct  MemberMap
 
class  WeakRawPtr
 
struct  WeakRefBase
 
struct  WeakRefTargetBase
 
struct  MemoryMetadataProxy
 
class  WeakRefServices
 
class  GUIDHASH
 
class  CryptographyStreamConversionInterface
 
class  CryptoKeyInterface
 
class  CryptoKey
 
class  SSHInterface
 
class  SSLInterface
 
struct  CellEdge
 
class  CellData
 
class  ConvexDecompositionInterface
 
struct  ConvEdge
 
struct  ConvexHullData
 
class  ConvexHullInterface
 
class  Delaunay3DInterface
 
class  ExactPredicates2DInterface
 
class  GeomConstants
 
class  DegeneratedInputErrorInterface
 
class  GeometryUtilsInterface
 
class  GraphNodeBase
 
class  GraphEdgeBase
 
class  GraphBase
 
class  GenericInterpolate
 
class  InterpolateTypeInterface
 
class  Poly
 
class  SimpleMeshObject
 
struct  Tetrahedron
 
class  Voronoi3DInterface
 
struct  Wires
 
class  GraphModelInterface
 
class  GraphTransaction
 
class  GraphNodeFunctions
 
class  GraphNodeResultBase
 
class  GraphNode
 
struct  IsZeroInitialized< GraphNode >
 
class  GraphLib
 
class  GraphModelHelper
 
class  GraphAttributeInterface
 
class  GraphMessageInterface
 
class  NodePathInterface
 
class  FastNodePathHash
 
class  AudioObjectInterface
 
struct  DrawDimension
 
struct  IsZeroInitialized< DrawDimension< T > >
 
struct  DrawRect
 
struct  IsZeroInitialized< DrawRect< T > >
 
struct  DrawPoint3d
 
struct  DrawDimension3d
 
struct  DrawVolume
 
struct  ImageHierarchy
 
class  ImageBaseInterface
 
class  ImageTextureInterface
 
class  ImageInterface
 
class  ImageLayerInterface
 
class  ImageFunctionsInterface
 
class  BITS
 
class  ColorProfileInterface
 
class  ColorProfileConvertInterface
 
class  ColorSpaceInterface
 
class  ExifInterface
 
class  ExifStaticInterface
 
class  ColorProfileLegacyProcessorInterface
 
class  ImageChannelTypeInterface
 
class  ImageChannelInterface
 
struct  BlendPixelHandlerStruct
 
class  ImagePixelBlendInterface
 
struct  IsZeroInitialized< PixelFormatGroup >
 
struct  PixelConstBuffer
 
struct  PixelMutableBuffer
 
struct  ImageBufferTemplate
 
struct  ConvertFuncChannelHelper
 
class  PixelFormatInterface
 
class  PixelFormatsInterface
 
class  PixelFormatDynamicInterface
 
class  PixelFormatGroupInterface
 
class  PixelFormatIterator
 
class  PixelFormatIndexedColorInterface
 
struct  PixelDepthInfo
 
struct  PixelDepthInfo< Pix8u >
 
struct  PixelDepthInfo< Pix8s >
 
struct  PixelDepthInfo< Pix16u >
 
struct  PixelDepthInfo< Pix16s >
 
struct  PixelDepthInfo< Pix32u >
 
struct  PixelDepthInfo< Pix32s >
 
struct  PixelDepthInfo< Pix16f >
 
struct  PixelDepthInfo< Pix32f >
 
struct  PixelDepthInfo< Pix64f >
 
struct  ChannelOffsetHelper
 
class  PixelFormatTemplateBase
 
struct  ImagePos
 
struct  GetPixelHandlerStruct
 
struct  SetPixelHandlerStruct
 
class  ImagePixelStorageInterface
 
struct  DeepImagePixelConstBuffer
 
struct  DeepImagePixelMutableBuffer
 
class  ImagePixelDeepImageStorageInterface
 
class  UpdateRegionObserver
 
class  VectorImageInterface
 
class  HalfFloat
 
class  LIMIT< HalfFloat< Float32 > >
 
class  ImageRegionObserverInterface
 
class  ImageRegionObservableInterface
 
class  ImageRegionObservableHandlerInterface
 
class  ImageRegionTilesObserverInterface
 
class  ImageRegionObserverStorage
 
class  ImageUrlCacheInterface
 
struct  LayerSetCompare
 
class  LayerSetInterface
 
class  MediaStreamAudioDataExportInterface
 
class  MediaBaseInterface
 
class  MediaConverterInterface
 
class  MediaConverterErrorInterface
 
class  MediaSessionWrongTypeErrorInterface
 
class  MediaStreamEOFErrorInterface
 
class  MediaSessionFileFormatHandlerInterface
 
class  MediaInputInterface
 
class  MediaOutputInterface
 
class  MediaOutputTextureInterface
 
class  MediaOutputUrlInterface
 
class  MediaSessionInterface
 
class  MediaStreamInterface
 
class  MediaStreamExifDataInterface
 
class  MediaStreamImageBaseInterface
 
class  MediaStreamImageDataImportInterface
 
class  MediaStreamImageDataExportInterface
 
class  MediaStreamImageDataForwardImportInterface
 
class  MediaStreamAudioDataImportInterface
 
class  MediaStreamFormatInterface
 
class  MediaStreamPropertiesInterface
 
class  LIMIT< Vector2d32 >
 
class  LIMIT< Vector2d64 >
 
class  LIMIT< Vector4d32 >
 
class  LIMIT< Vector4d64 >
 
class  LIMIT< Vector32 >
 
class  LIMIT< Vector64 >
 
class  LIMIT< Matrix32 >
 
class  LIMIT< Matrix64 >
 
class  LIMIT< Color32 >
 
class  LIMIT< Color64 >
 
class  LIMIT< ColorA32 >
 
class  LIMIT< ColorA64 >
 
class  BigIntegerInterface
 
class  BigInteger
 
class  BlendTweenInterface
 
class  BlendAnimationInterface
 
class  BlendFunctionInterface
 
class  Complex
 
class  FFTInterface
 
class  Fraction
 
class  DefaultReification
 
class  Dispatch1
 
class  Dispatch1< ALGORITHM, std::tuple< TYPES... >, REIFICATION >
 
class  Dispatch2
 
class  Dispatch2< ALGORITHM, std::tuple< TYPES... >, REIFICATION >
 
struct  GradientKnot
 
class  GradientInterface
 
class  GradientRenderDataInterface
 
struct  IndexedGradientKnot
 
class  SortedGradientKnots
 
class  IndexedGradientSampler
 
class  GradientSampler
 
class  PerformanceBaseArray
 
struct  KDTreeNode
 
struct  KDTreeNearest
 
struct  KDStackArray
 
class  KDTree
 
class  MatrixNxM
 
class  MatrixNxMInterface
 
class  ConstMatrixNxMInterface
 
struct  PRSMatrixData
 
class  NoiseInterface
 
class  RenderNoiseInterface
 
class  NURBSTests
 
class  NURBSCurveWithContinuity
 
class  NURBSCurveInterface
 
struct  KnotInfo
 
class  NURBSCurve
 
class  PolynomSolver
 
class  Quaternion
 
struct  MathFuncHelper
 
struct  MathFuncHelper< Vec2< T >, FUNC >
 
struct  MathFuncHelper< Vec3< T >, FUNC >
 
struct  MathFuncHelper< Vec4< T >, FUNC >
 
struct  MathFuncHelper< Col3< T >, FUNC >
 
struct  MathFuncHelper< Col4< T >, FUNC >
 
struct  SplineMapperKnot
 
class  SplineMapperInterface
 
struct  PrimitiveInformation
 
struct  MeshDistanceData
 
struct  SplineDistanceData
 
class  DistanceQueryInterface
 
class  CustomDataTagDisplayInterface
 
class  MeshAttributeClassInterface
 
class  CustomDataTagClassInterface
 
class  MeshAttribute
 
class  PolyData
 
class  PolygroupInformation
 
class  VoxelizationInterface
 
class  ChangeListInterface
 
class  FileMonitorItemInterface
 
class  FileMonitor
 
class  FormulaParseErrorInterface
 
class  FormulaExecutionErrorInterface
 
class  FormulaNumberErrorInterface
 
class  FormulaParserCacheInterface
 
class  FormulaParserInterface
 
struct  GmlNode
 
struct  GmlTarget
 
struct  GmlNodeAttribs
 
class  GmlGraphInterface
 
class  GmlWriterInterface
 
class  IoDocument
 
class  IoXmlNodeInterface
 
class  IoXmlParser
 
class  ProfilerConstant
 
class  Profiler
 
class  ProfileManagerInterface
 
class  ProfilingPoint
 
struct  ProfilingPointHelper
 
class  ProgressMonitorInterface
 
class  RamDiskInterface
 
class  RuleParserInterface
 
class  ParseHelper
 
class  SourceControlChangeEntry
 
class  SourceControlInterface
 
class  SqlDatabaseInterface
 
class  RegularExpressionInterface
 
class  SubDataInterface
 
class  SubDataOperationInterface
 
class  UnitTestErrorInterface
 
class  UnitTestInterface
 
class  UnitTestComponent
 
class  UpdateJobEvent
 
class  ConditionVariableDependency
 
class  HttpCodeErrorInterface
 
class  AioStatusInterface
 
class  AioReaderInterface
 
class  AioWriterInterface
 
class  AioServiceInterface
 
class  NetworkErrorInterface
 
class  NetworkTimeoutErrorInterface
 
struct  NetworkIpAddressStruct
 
class  NetworkAdapterInterface
 
class  NetworkConnectionInterface
 
class  NetworkIpInterface
 
struct  NetworkSockAddrIn
 
class  NetworkIpAddrInterface
 
class  NetworkIpAddrPortInterface
 
class  NetworkIpAddr
 
class  NetworkIpAddrPort
 
class  SSHNetworkConnectionInterface
 
class  SSLNetworkConnectionInterface
 
class  NetworkTcpSocketInterface
 
class  NetworkTcpConnectionInterface
 
class  NetworkTcpServerInterface
 
struct  NetworkTcpConnectionOptions
 
class  NetworkTcpInterface
 
class  NetworkUdpSocketInterface
 
class  NetworkUdpBoundSocketInterface
 
class  NetworkUdpChannelInterface
 
class  NetworkUdpSenderInterface
 
class  NetworkUdpServerInterface
 
struct  NetworkUdpChannelOptions
 
struct  NetworkUdpSenderOptions
 
struct  NetworkUdpServerOptions
 
class  NetworkUdpInterface
 
class  UrlRedirectInterface
 
class  NetworkOAuthSessionInterface
 
class  NetworkProxyInterface
 
struct  ServiceDiscovery
 
struct  ResourceIdentifier
 
struct  ServiceProviderDetails
 
class  ServiceAnnouncementRequestInterface
 
class  ServiceSubscriptionRequestInterface
 
class  ServiceAnnouncementInterface
 
class  ServiceSubscriptionInterface
 
class  ServiceBusInterface
 
class  SmtpErrorInterface
 
struct  SmtpReceiver
 
class  SmtpMailInterface
 
class  NetworkWebServerInterface
 
class  NetworkIpHandlerInterface
 
class  NetworkHttpHandlerInterface
 
class  NetworkWebSocketConnectionInterface
 
class  NetworkWebSocketSignalInterface
 
class  NetworkWebSocketClientConnectionInterface
 
class  NetworkWebSocketServerInterface
 
class  NetworkZeroConfBrowserInterface
 
class  NetworkZeroConfServiceInterface
 
class  NetworkZeroConfInterface
 
class  NodeContextAssetInterface
 
struct  NullValueFunctions< nodes::TemplateArguments >
 
class  NimbusBaseInterface
 
class  CodeExchangeInterface
 
struct  ErrorStorage
 
class  PyModuleInterface
 
struct  ResultOffsetHelper
 
class  LocalStringStorage
 
struct  Runtime
 
struct  LoadRuntime
 
class  LibraryInterface
 
struct  DocStringMeta
 
class  VmDebuggerConnectionInterface
 
class  VirtualMachineScopeInterface
 
class  VirtualMachineInterface
 
class  FilterInterface
 
class  FilterCommandQueueInterface
 
class  FilterContextInterface
 
class  FilterImageInterface
 
class  CoreFoundationCreatedPointerHandler
 
class  CFStrongRef
 
class  NSCreatedPointerHandler
 
class  NSStrongRef
 
struct  NSStrongId
 
class  SystemWindows
 
class  VolumeInterface
 
class  GridAccessorRef
 
class  GridAccessorInterface
 
class  GridAccessorCreationInterface
 
class  GridAccessorRef< Generic >
 
struct  VolumeCommandData
 
class  GridIteratorRef
 
class  GridIteratorInterface
 
class  GridIteratorCreationInterface
 
struct  VolumeRay
 
struct  VolumeRayHit
 
class  VolumeRayIntersectorRef
 
class  VolumeRayIntersectorInterface
 
class  VolumeRayIntersectorCreationInterface
 
class  VolumeRayIntersectorRef< Generic >
 
struct  SDFFilterSettings
 
struct  FilterSettings
 
struct  FieldSampleData
 
struct  VolumeConversionPolygon
 
class  VolumeToolsInterface
 
class  PointsToVolumeListInterface
 

Typedefs

using InsertPointType = Tuple< Id, Vector, Vector2d, ColorA >
 
using OutputStreamDecoratorFactory = Delegate< Result< OutputStreamRef >(const OutputStreamRef &stream)>
 
using AssetRepositoryUpdate = Tuple< AssetDescription, BaseArray< AssetBase > >
 
using BuiltinAssetLoader = Delegate< Result< Bool >(const Block< const Id > &types, const Id &aid, ASSET_FIND_MODE findMode, const ValueReceiver< const Asset &, const DataDictionary & > &receiver)>
 
using DndAsset = Tuple< AssetDescription, Url, String >
 
using AddAssetMetaData = HashMap< InternedId, Tuple< Data, AssetMetaDataInterface::KIND > >
 
using PresetStorage = DataDictionary
 
using DataDescriptionEntry = DataDictionary
 
using LanguageStringDataDescriptionDefinition = HashMap< Id, DataDescriptionDefinition > MAXON_FORWARD("maxon/datadescriptiondefinition.h")
 
using LanguageDictionary = DataDictionary
 
using NimbusForwardRef = ForwardRefWithExtraBase< NimbusRef, NimbusBaseRef >
 
using CustomLicenseItemDelegate = Delegate< Result< void >(const InternedId &featureId, const String &provider, Bool isValid, const CString &jwtString)>
 
using NodeMaterialLinkResolveFunc = Delegate< Result< ::BaseList2D * >(::BaseLink *link, ::BaseDocument *baseDocument)>
 
using DescCompareEntry = Tuple< Bool, BaseContainer, DescID, maxon::String >
 
using CommandGetStateDelegate = Delegate< Int32(::BaseDocument *)>
 
using CreateMaterialWithDataDelegate = Delegate<::BaseMaterial *(::BaseDocument *, const Data &textureUrlOrColor)>
 
using CreateDefaultMaterialDelegate = Delegate<::BaseMaterial *(::BaseDocument *)>
 
using PyBaseElementFactoryType = Factory< PythonElementBaseRef(BaseList2D *bl)>
 
using PyEmbeddedElementFactoryType = Factory< PythonElementEmbeddedRef(BaseList2D *bl, const DescID &parameter)>
 
using PyDirectoryElementFactoryType = Factory< PythonElementBaseRef(Url dir)>
 
using PyScriptElementFactoryType = Factory< PythonElementScriptRef(BaseList2D *bl)>
 
using GetExtraDataCallbackType = Delegate< DelegateBase(const Id &)>
 
using PatchC4DDescriptionEntryDelegate = Delegate< Result< void >(BaseContainer &param)>
 
using CommandCacheMap = HashMap< Id, CommandCacheRef >
 
using CommandCacheDataRef = StrongRef< CommandCacheData >
 
template<typename T >
using ABIReturnType = ABIParamType< T >
 
using IndexPair = Pair< Int, Int >
 
using Int16 = int16_t
 
using UInt16 = uint16_t
 
using Int32 = int32_t
 
using UInt32 = uint32_t
 
using Int64 = int64_t
 
using UInt64 = uint64_t
 
using Bool = bool
 
using Float32 = float
 
using Float64 = double
 
using Char = char
 
using UChar = unsigned char
 
using Int = Int64
 
using UInt = UInt64
 
using Float = Float64
 
using Utf32Char = char32_t
 
using Utf16Char = char16_t
 
using SysChar = char
 
using HashInt = UInt
 
using OverloadRank0 = PrivateOverloadRank0 *
 
using OverloadRank1 = PrivateOverloadRank1 *
 
using OverloadRank2 = PrivateOverloadRank2 *
 
using OverloadRank3 = PrivateOverloadRank3 *
 
using OverloadRank4 = PrivateOverloadRank4 *
 
using OverloadRank5 = PrivateOverloadRank5 *
 
using OverloadRankMax = OverloadRank5
 
template<typename T , Int N>
using AddArrayT = T[N]
 
template<typename T >
using AddArrayOfUnknownBoundT = T[]
 
template<typename TO , typename FROM , Bool SAFE>
using GenericCastReturnType = std::enable_if< GenericCastTrait< TO, typename maxon::details::MakeLValueConst< FROM >::type, SAFE >::value, typename GenericCastTrait< TO, typename maxon::details::MakeLValueConst< FROM >::type, SAFE >::ReturnType >
 
using InitMTable = void(*)()
 
using DestructorPointer = void(*)(const void *)
 
using BoolLValue = DefaultLValue< Bool >
 
template<typename T >
using WritableArrayInterface = const NonConstArray< T >
 
using AtomicInt32 = Atomic32< Int32 >
 
using AtomicUInt32 = Atomic32< UInt32 >
 
using AtomicInt64 = Atomic64< Int64 >
 
using AtomicUInt64 = Atomic64< UInt64 >
 
using AtomicInt = Atomic64< Int >
 
using AtomicUInt = Atomic64< UInt >
 
using AtomicInt16 = Atomic16< Int16 >
 
using AtomicUInt16 = Atomic16< UInt16 >
 
using AtomicInt8 = Atomic8< Char >
 
using AtomicUInt8 = Atomic8< UChar >
 
using AtomicFloat32 = AtomicFloatType< Float32 >
 
using AtomicFloat64 = AtomicFloatType< Float64 >
 
using AtomicVoidPtr = AtomicPtr< void >
 
using BackgroundEntryTuple = Tuple< WeakRef< BackgroundProgressRef >, Int >
 
template<typename T , Int COUNT, Int MINCHUNKSIZE = COUNT, BASEARRAYFLAGS MEMFLAGS = BASEARRAYFLAGS::NONE, typename ALLOCATOR = DefaultAllocator>
using BufferedBaseArray = typename BufferedBaseArraySelector< COUNT, MINCHUNKSIZE, MEMFLAGS, ALLOCATOR >::template Type< T >
 
using BitSet = BaseBitSet< DefaultAllocator >
 
template<typename T >
using Pointer = BaseRef< T, PointerHandler >
 
template<typename T >
using UniqueRef = BaseRef< T, UniqueRefHandler >
 
template<typename T >
using StrongRef = BaseRef< T, StrongRefHandler >
 
template<typename T >
using StrongCOWRef = BaseRef< const T, StrongCOWRefHandler >
 
template<typename T >
using AutoMem = UniqueRef< RawMem< T > >
 
template<typename T >
using StridedBlock = Block< T, true >
 
template<typename T , Bool STRIDED = false>
using MoveBlock = Block< T, STRIDED, true >
 
using PersistentIdBuffer = BufferedBaseArray< Int64, 10 >
 
using CrashReportPropertyArray = BlockArray< CrashReportPropertyItem, 8 >
 
using DataDescriptionWithUIAndString = Tuple< DataDescription, DataDescription, DataDescription >
 
using LanguageStringDataDescription = HashMap< Id, DataDescription >
 
using DataDescriptionWithUIAndLanguageStrings = Tuple< DataDescription, DataDescription, LanguageStringDataDescription >
 
using VariadicIdsElement = Tuple< Int, Id, String, HashMap< Id, Int > >
 
using VariadicIdsType = Array< VariadicIdsElement >
 
using ContextVarTuple = Tuple< DataDictionary, GetDataCallbackType >
 
using ContextVarsMap = HashMap< Id, ContextVarTuple >
 
using GetDescEntriesCallbackType = Delegate< Result< Tuple< InternedId, DataDictionary, DataDictionary > >(const InternedId &id, GETDATAFLAGS flags)>
 
using ConditionToken = Tuple< const CString &, const CString &, CONDITIONTOKENTYPE >
 
using ProcessEnumListDelegate = Delegate< Result< void >(const Id &epId, const DataDictionary &guiEntry, const AssetRepositoryRef &repository, const Data *filterData, const ValueReceiver< Tuple< Id, Data, String > && > &addValue)>
 
using EnumVariableResolveDelegate = Delegate< Result< CString >(const CString &variable, const CString &fullString, const AssetRepositoryRef &repository, const GetDataCallbackType &getDataCallback, Opt< const DataDictionary & > dataEntry, Opt< const DataDictionary & > guiEntry)>
 
using GetDataCallbackType = Delegate< Result< Data >(const InternedId &id, const DataDictionary &dataEntry, GETDATAFLAGS flags)>
 
using DataDescriptionDefinitionWithUIAndLanguageStrings = Tuple< DataDescriptionDefinition, DataDescriptionDefinition, LanguageStringDataDescriptionDefinition >
 
using BuildSubMenuValueReceiver = ValueReceiver< SubMenuEntry && >
 
using DescriptionMessageCheck = Delegate< Result< DESCRIPTIONMESSAGECHECKFLAGS >(const DataDictionary &userData)>
 
using DescriptionMessageBuildSubMenu = Delegate< Result< void >(const DataDictionary &userData, const BuildSubMenuValueReceiver &menuEntries)>
 
using DescriptionMessageCall = Delegate< Result< void >(const DataDictionary &userData, DataDictionary &multiSelectionStorage)>
 
using DescriptionMessageFunction = Tuple< Id, DescriptionMessageCheck, DescriptionMessageBuildSubMenu, DescriptionMessageCall >
 
using DataFormatReaderFactory = Factory< DataFormatReaderRef(UrlOrInputStream &&)>
 
using DataFormatWriterFactory = Factory< DataFormatWriterRef(UrlOrOutputStream &&)>
 
using KeyValueConversionFunc = void(void *, Char *)
 
using CreateIoHelperFunc = ResultPtr< void >()
 
using DeleteIoHelperFunc = void(void *)
 
using ReadIoHelperFunc = Result< void >(DataSerializeInterface *, void *, void *, UInt)
 
using WriteIoHelperFunc = Result< void >(DataSerializeInterface *, void *, void *, UInt)
 
using WidthConversionFunc = Bool(void *source, void *dest)
 
using ReferenceSubstitutionFunction = Delegate< Result< const ObjectInterface * >(const ObjectInterface *input)>
 
using StreamSubstitutionFunction = Delegate< Result< ObjectRef >(ObjectRef input, const Id &compressorId)>
 
using GetChildrenTypesCallback = Delegate< Result< Tuple< String, Bool > >(const Member &elementType, const ParametricTypeInterface *parametricType)>
 
using GetDataTypeNameDelegate = Delegate< Result< Tuple< String, String > >(DATATYPEBUILDERNAME category, const DataType &dt, const GetChildrenTypesCallback &getChildrenTypes, const ParametricTypeInterface *parentTypeId, const ParametricTypeInterface **skipParentType)>
 
using GetChildrenCountDelegate = Delegate< Tuple< Int, Int, Bool >()>
 
using InstantiateDataTypeDelegate = Delegate< Result< DataType >(const BaseArray< Member > &members)>
 
using GetParentTypeSupportDelegate = Delegate< Block< ParametricType >()>
 
using GetFolderDelegate = Delegate< Block< const Id >()>
 
using RemoteDateTime = LocalDateTime
 
template<typename I >
using ObjectBaseRef = typename maxon::details::ObjectBaseRefImpl< I::REFERENCE_KIND >::type
 
template<typename... T>
using ValueReceiver = Delegate< Result< Bool >(T...)>
 
using QueryStartupOrder = void(*)(BaseArray< Url > &dllsToLoad)
 
template<typename EXECUTION >
using ExecutionInterface = JobInterfaceTemplate< EXECUTION >
 
template<typename FACTORY >
using FactoryBase = RefBase< FactoryFunctions< FACTORY, FactoryInterface::ReferenceFunctions< RefBaseFn< DirectRef< const FactoryInterface, StrongRefHandler, FACTORY > >> >>
 
using Group = void
 
using IdAndVersion = Tuple< Id, Id >
 
using UIntegerBase = UInt32
 
using NativeUInteger = UInteger< SIZEOF(Int) *8 >
 
template<typename T , Bool HAS_ERROR>
using AddResult = typename maxon::details::AddResultHelper< T, HAS_ERROR >::type
 
using ExtractCallback = Delegate< Result< Bool >(const String &inputName, Url &outputName, IOATTRIBUTES &fileAttributes)>
 
using IoProgressDelegate = Delegate< Result< void >(Int64 alreadyRead, Int64 totalBytes)>
 
using PIPEHANDLE = int
 
using UrlOrInputStream = UrlOrStream< InputStreamRef >
 
using UrlOrOutputStream = UrlOrStream< OutputStreamRef >
 
template<typename RESULTVALUETYPE >
using FutureRef = JobResultRef< RESULTVALUETYPE >
 
using TransformColorDelegate32 = Delegate< Color32(const Color32 &)>
 
using TransformColorDelegate64 = Delegate< Color64(const Color64 &)>
 
using TransformValueDelegate32 = Delegate< Float32(const Float32 &)>
 
using TransformValueDelegate64 = Delegate< Float64(const Float64 &)>
 
using TransformColorDelegate = TransformColorDelegate64
 
using TransformValueDelegate = TransformValueDelegate64
 
using CreateNewMachineCallback = Delegate< Result< MachineRef >(const String &machineUuid)>
 
using CheckExistingMachineCallback = Delegate< Result< void >(const MachineRef &machineRef)>
 
using CreateObjectRefFunc = ObjectRef(*)()
 
template<typename K , typename V >
using WritableMapInterface = const NonConstMap< K, V >
 
using SquareMatrix32 = SqrMat3< Vector32 >
 
using SquareMatrix64 = SqrMat3< Vector64 >
 
using SquareMatrix = SqrMat3< Vector >
 
using Matrix32 = Mat3< Vector32 >
 
using Matrix64 = Mat3< Vector64 >
 
using Matrix = Mat3< Vector >
 
using SquareMatrix2d32 = SqrMat2< Vector2d32 >
 
using SquareMatrix2d64 = SqrMat2< Vector2d64 >
 
using SquareMatrix2d = SqrMat2< Vector2d >
 
using Matrix2d32 = Mat2< Vector2d32 >
 
using Matrix2d64 = Mat2< Vector2d64 >
 
using Matrix2d = Mat2< Vector2d >
 
using SquareMatrix4d32 = SqrMat4< Vector4d32 >
 
using SquareMatrix4d64 = SqrMat4< Vector4d64 >
 
using SquareMatrix4d = SqrMat4< Vector4d >
 
using MultiIndex64 = MultiIndex< UInt64 >
 
template<typename TO , typename FROM >
using Out = std::is_constructible< TO, FROM >
 
using ClassTransformer = Delegate< Result< void >(ClassInterface *)>
 
template<typename C , typename... INTERFACES>
using Component = ComponentWithBase< C, ComponentRoot, INTERFACES... >
 
template<typename FROM , typename C , typename... INTERFACES>
using AdapterComponent = ComponentWithBase< C, AdapterRoot, FROM, INTERFACES... >
 
template<typename... INTERFACES>
using SelfPtr = typename ComponentHelper< ComponentRoot, INTERFACES... >::type::SelfPtr
 
using ObservableForwardFunction = Result< Data >(*)(const DelegateBase &observerFunction, const Block< const ConstDataPtr > &data)
 
using FunctionBaseWeakRef = WeakRef< FunctionBaseRef >
 
using OpaqueRef = StrongRef< OpaqueBase >
 
template<typename T >
using Optional = Opt< T >
 
template<typename T , typename ARRAY = BaseArraySelector<>, typename COMPARE = DefaultCompare, Bool KEEP_DUPLICATES = false>
using MinimalElements = MaximalElements< T, ARRAY, COMPARE, KEEP_DUPLICATES, true >
 
using JobCancelDelegate = Delegate< Result< void >(const ProgressRef &progressRef)>
 
using Frame = Range< Vector2d >
 
using IntFrame = Range< IntVector2d >
 
using SecureRandomProvider = Pointer< _SecureRandomProvider >
 
template<Bool ZERO_BASED, size_t... VALUES>
using PartialSumSequence = typename maxon::details::PartialSumSequenceHelper< ZERO_BASED, std::index_sequence<>, 0, VALUES... >::type
 
template<typename T >
using WritableSetInterface = const NonConstSet< T >
 
using StreamConversionFactory = Factory< StreamConversionRef(const DataDictionary &)>
 
using Utf16CharBuffer = BufferedBaseArray< Utf16Char, 512 >
 
using Utf32CharBuffer = BufferedBaseArray< Utf32Char, 256 >
 
using FROMSTR = void(*)(void *p, const Block< const Utf32Char > &str, Int &processed, const String &formatStatement, Bool &error)
 
template<typename T >
using Synchronized = SynchronizedValue< T, Spinlock >
 
template<typename T >
using RWSynchronized = SynchronizedValue< T, ARWLock >
 
using ExecuteProgramCallback = Int32(*)(SystemProcessObjectRef processRef, EXECUTEPROGRAMCALLBACK cmd, void *userdata, const Url &logfile)
 
using ThreadRef = ThreadRefTemplate< ThreadInterface >
 
template<typename T1 , typename T2 >
using Pair = typename maxon::details::PairSelector< T1, T2 >::type
 
template<Int N, typename T >
using HomogenousTupleType = typename maxon::details::HomogenousTupleTypeHelper< N, T >::type
 
using UnitsArray = StrongCOWRef< BaseArray< Unit > >
 
using UrlScheme = Id
 
using UrlIoShowInOSDelegate = Delegate< Result< Bool >(const Url &url, IOSHOWINOSFLAGS flags)>
 
using ResultMem = ResultMemT< Bool >
 
template<typename... BASES>
using NonEmptyBases = typename maxon::details::NonEmptyBasesHelper< typename std::conditional< STD_IS_REPLACEMENT(empty, BASES), EmptyClass, BASES >::type... >::type
 
using TOSTR = void(*)(String &result, const void *ptr, const FormatStatement *formatStatement)
 
template<typename T >
using ResultPtr = ResultMemT< T * >
 
using ThreadedUIUpdateBaseRef = StrongRef< ThreadedUIUpdateBase >
 
template<typename T , Bool ERROR_WHEN_AMBIGUOUS = true>
using SingleValueReceiver = UniqueValueReceiver< T, ERROR_WHEN_AMBIGUOUS >
 
using Vector32 = Vec3< Float32, 1 >
 
using Vector64 = Vec3< Float64, 1 >
 
using Vector = Vec3< Float, 1 >
 
using IntVector32 = Vec3< Int32, 1 >
 
using UIntVector32 = Vec3< UInt32, 1 >
 
using IntVector64 = Vec3< Int64, 1 >
 
using IntVector = Vec3< Int, 1 >
 
using Color32 = Col3< Float32, 1 >
 
using Color64 = Col3< Float64, 1 >
 
using Color = Col3< Float, 1 >
 
using GenericVector = Vec3< GenericArithmetic, 1 >
 
using Vector2d32 = Vec2< Float32, 1 >
 
using Vector2d64 = Vec2< Float64, 1 >
 
using Vector2d = Vec2< Float, 1 >
 
using IntVector2d32 = Vec2< Int32, 1 >
 
using UIntVector2d32 = Vec2< UInt32, 1 >
 
using IntVector2d64 = Vec2< Int64, 1 >
 
using UIntVector2d64 = Vec2< UInt64, 1 >
 
using IntVector2d = Vec2< Int, 1 >
 
using GenericVector2d = Vec2< GenericArithmetic, 1 >
 
using Vector4d32 = Vec4< Float32, 1 >
 
using Vector4d64 = Vec4< Float64, 1 >
 
using Vector4d = Vec4< Float, 1 >
 
using IntVector4d32 = Vec4< Int32, 1 >
 
using IntVector4d64 = Vec4< Int64, 1 >
 
using IntVector4d = Vec4< Int, 1 >
 
using ColorA32 = Col4< Float32, 1 >
 
using ColorA64 = Col4< Float64, 1 >
 
using ColorA = Col4< Float, 1 >
 
using GenericVector4d = Vec4< GenericArithmetic, 1 >
 
using MemoryObserverCallback = MEMORY_OBSERVER_FLAGS(*)(void *callbackData, const void *target, MEMORY_OBSERVER_STATE state)
 
using MemoryMetadataDestructor = void(*)(void *metadata)
 
using BLOCK_CIPHER_CTR_CALLBACK = Delegate< void(Int block, Int blockSize, UChar *nonce)>
 
using LIBSSH2_PASSWD_CHANGEREQ_FUNC = void(*)(LIBSSH2_SESSION *session, char **newpw, int *newpw_len, void **abstract)
 
typedef int(* sslctxsetverifycallback) (int, X509_STORE_CTX *)
 
using SimplePolygon = Poly< Int32 >
 
using UVWPolygon = Poly< Vector >
 
using TangentPair = Tuple< Vector, Vector >
 
using TangentPair2d = Tuple< Vector2d, Vector2d >
 
using TimeStamp = UInt64
 
using GraphConnection = Tuple< GraphNode, Wires >
 
using IoNodePath = Tuple< NodePath, InternedId >
 
using IoNodeConnection = Tuple< IoNodePath, IoNodePath >
 
using IoGraphNode = Tuple< GraphNode, InternedId >
 
using GraphAttributeMap = HashMap< InternedId, ConstDataPtr >
 
using PathBlock = Block< const InternedId >
 
using DrawDimensionInt = DrawDimension< Int >
 
using DrawDimensionFloat = DrawDimension< Float >
 
using DrawRectInt = DrawRect< Int >
 
using DrawRectFloat = DrawRect< Float >
 
using DrawPoint3dInt = DrawPoint3d< Int >
 
using DrawPoint3dFloat = DrawPoint3d< Float >
 
using DrawDimension3dInt = DrawDimension3d< Int >
 
using DrawDimension3dFloat = DrawDimension3d< Float >
 
using DrawVolumeInt = DrawVolume< Int >
 
using DrawVolumeFloat = DrawVolume< Float >
 
using Pix = UChar
 
using Pix8u = UChar
 
using Pix8s = Char
 
using Pix16u = UInt16
 
using Pix16s = Int16
 
using Pix32u = UInt32
 
using Pix32s = Int32
 
using Pix32f = Float32
 
using Pix64f = Float64
 
using Pix16f = HalfFloat< Pix32f >
 
using BlendPixelHandlerRef = StrongRef< BlendPixelHandlerStruct >
 
using ChannelOffsets = Block< const BITS >
 
using ImageConstBuffer = ImageBufferTemplate< PixelConstBuffer >
 
using ImageMutableBuffer = ImageBufferTemplate< PixelMutableBuffer >
 
using CONVERTPIXELFUNC = Delegate< Result< void >(const PixelMutableBuffer &dst, Int count, const PixelConstBuffer &src, GETPIXELFLAGS flags)>
 
using CONVERTPIXELFUNCSTATIC = Result< void >(*)(const PixelMutableBuffer &dst, Int count, const PixelConstBuffer &src, GETPIXELFLAGS flags, const ChannelOffsets &dstChannelOffset, const ChannelOffsets &srcChannelOffset)
 
using ConvertFuncChannelHelperRef = StrongRef< ConvertFuncChannelHelper >
 
using UpdateRegion = Range< IntVector2d >
 
using BitDepthConfig = const DataType
 
using MediaOutputSelectionHandler = Delegate< Result< SELECTIONHANDLERRESULT >(const MediaStreamRef &stream, const MediaStreamFormat &props)>
 
using MediaSessionProgressCallback = Delegate< void(const ProgressRef &progress, Float percent, const TimeValue &duration, const TimeValue &expectedTotalTime)>
 
using AnimBlendTweenCallback = Delegate< void(const BlendAnimationRef &self, const BlendTweenRef &tween, ANIMBLENDSTATE state, const Data &animValue)>
 
using Complex32 = Complex< Float32 >
 
using Complex64 = Complex< Float64 >
 
using MatrixNxM32 = MatrixNxM< Float32 >
 
using MatrixNxM64 = MatrixNxM< Float64 >
 
using MatrixNxMComplex32 = MatrixNxM< Complex32 >
 
using MatrixNxMComplex64 = MatrixNxM< Complex64 >
 
using PRSMatrix64 = PRSMatrixData< Vector64 >
 
using PRSMatrix32 = PRSMatrixData< Vector32 >
 
using PRSMatrix = PRSMatrixData< Vector >
 
using FbmTableRef = OpaqueRef
 
using FbmTablePtr = OpaqueBase const *
 
using Quaternion32 = Quaternion< Float32 >
 
using Quaternion64 = Quaternion< Float64 >
 
template<typename T >
using enable_if_scalar = typename std::enable_if< STD_IS_REPLACEMENT(scalar, T), T >::type
 
template<typename T >
using enable_if_not_scalar = typename std::enable_if<!STD_IS_REPLACEMENT(scalar, T), T >::type
 
template<typename T >
using enable_if_float = typename std::enable_if< STD_IS_REPLACEMENT(floating_point, T), T >::type
 
template<typename T >
using enable_if_not_float = typename std::enable_if<!STD_IS_REPLACEMENT(floating_point, T), T >::type
 
template<typename T >
using enable_if_integral = typename std::enable_if< STD_IS_REPLACEMENT(integral, T), T >::type
 
template<typename T >
using enable_if_not_integral = typename std::enable_if<!STD_IS_REPLACEMENT(integral, T), T >::type
 
using VariadicInstance = Tuple< Id, DataDictionary >
 
using IconProvider = Delegate< Result< Url >(const CString &)>
 
using SCConversionFunction = Delegate< Result< Data >(const CString &val)>
 
using SCTypeConversion = HashMap< CString, SCConversionFunction >
 
using SQLDatabaseError = IllegalStateError
 
using SubDataPath = BaseArray< Data >
 
using SubDataPathBlock = Block< const Data >
 
using AioBuffer = BaseArray< Char >
 
using SOCKET = int
 
using ReturnResolveError = Result< void >
 
using SSH_CHANGE_PASSWORD_CALLBACK = void(*)(String &newPassword)
 
typedef Char NETWORKCHAR
 
typedef int SocketT
 
using HandleRequestDelegate = Delegate< Result< void >(const NetworkWebServerRef &server, const NetworkHttpHandlerRef &remoteConnection, const String &file, const DataDictionary &request)>
 
using IndexSelectionType = RangeSet< UInt32, BurstTrieMapSelector< 4, 20 > >
 
using IndexSelection = StrongCOWRef< IndexSelectionType >
 
using WeakNimbusBaseRef = WeakRef< NimbusBaseRef >
 
using FunctionRegistration = Delegate< Result< void >(py::NativePyCFunctionWithKeywords func)>
 
using NativePyCFunctionTable = Tuple< const Char *, py::NativePyCFunctionWithKeywords >
 
using PyChar = Char
 
using FilterProgressMonitorFunction = Bool(*)(void *userPtr, Float progress)
 
template<typename T >
using CFAutoReference = CFStrongRef< T >
 
template<typename T >
using NSAutoReference = NSStrongRef< T >
 
using GridAccessorBase = GridAccessorRef< Generic >
 
using VolumeRayIntersectorBase = VolumeRayIntersectorRef< Generic >
 
using DelegatePointObjectsPair = Pair< Delegate< Result< void >(void *, PointsToVolumeListRef &)>, BaseArray< void * > >
 
using DelegatePointObjectsPairList = BaseArray< DelegatePointObjectsPair >
 

Enumerations

enum class  COMMAND_ASSET_STATE {
  NONE ,
  ENABLED ,
  CHECKED ,
  HIDDEN ,
  HAS_OPTIONS
}
 
enum class  ASSETLICENSETYPE : UInt64 {
  NONE ,
  ENABLE_IN_SUBSCRIPTION ,
  SHOW_IN_SUBSCRIPTION ,
  ENABLE_IN_PERPETUAL ,
  SHOW_IN_PERPETUAL ,
  ENABLE_IN_TRIAL ,
  SHOW_IN_TRIAL ,
  ENABLE_IN_LITE ,
  SHOW_IN_LITE ,
  ENABLE_IN_STUDENT ,
  SHOW_IN_STUDENT ,
  ENABLE_IN_EDUCATION ,
  SHOW_IN_EDUCATION ,
  ENABLE_IN_CINEWARE ,
  SHOW_IN_CINEWARE ,
  ONLY_IN_MAXONONE ,
  ENABLE_IN_ALL ,
  SHOW_IN_ALL ,
  ALLBITS
}
 
enum class  ASSET_FIND_MODE {
  NONE ,
  LATEST ,
  ALL ,
  WITHOUT_BASES ,
  WITH_DELETED ,
  PREFIX ,
  RANDOMIZED_ORDER ,
  CHECK_CANCELLATION ,
  PRIVATE_QUERY_REPOSITORY_VISIBILITY
}
 
enum class  REPOSITORYINDEXSTATE {
  NONE ,
  PENDING ,
  RUNNING ,
  EXISTS
}
 
enum class  OUTPUTLOCATION {
  BETA ,
  C4D ,
  NET ,
  ALL
}
 
enum class  ASSETINSERTOBJECTMODE {
  ASOBJECT ,
  ASINSTANCE ,
  ASRENDERINSTANCE ,
  ASXREF
}
 
enum class  GENERATESCENEPREVIEWIMAGEFLAGS {
  NONE ,
  ISORIGINALDOCUMENT ,
  FRAMESCENE ,
  PREVIEWRENDER ,
  GEOMETRYONLY ,
  AUTODETECT_RENDERENGINE
}
 
enum class  OPENSAVEASSETDIALOGFLAGS {
  NONE ,
  ALLOW_EDIT_ID ,
  ALLOW_EDIT_NAME ,
  SHOW_VERSION ,
  ALLOW_EMPTY_CATEGORY ,
  SHOW_MAKE_DEFAULT
}
 
enum class  ASSETPOPUPOPTIONS {
  NONE ,
  POPUPMODE ,
  MODAL ,
  EXECUTELOAD ,
  ALLOWDRAGANDDROP ,
  ALLOWPINPOPUP ,
  SHOWCATEGORIESONLY ,
  SHOWKEYWORDSONLY ,
  SHOWCATEGORYLIST ,
  SHOWQUICKTABS ,
  DISPLAYASLIST ,
  HIDEWATCHFOLDERS ,
  COMMANDER
}
 
enum class  MASTERFILTER {
  ALL ,
  OBJECTS ,
  MATERIALS ,
  MEDIA ,
  NODES ,
  SCENE_NODES ,
  SCENES ,
  PRESETS ,
  SPECIAL
}
 
enum class  COMMANDSTATE {
  DISABLED ,
  ENABLED
}
 
enum class  COMMANDRESULT {
  OK ,
  SKIP ,
  BREAK
}
 
enum class  INTERACTIONTYPE {
  NONE ,
  START ,
  ITERATE ,
  END ,
  REALTIME
}
 
enum class  MOVE_MODE {
  KEEP_SOURCE ,
  DESTRUCT_SOURCE
}
 
enum class  NO_MATCH_TYPE { VALUE }
 
enum class  ENUM_DONT_INITIALIZE { VALUE }
 
enum class  IN_PLACE_TYPE { VALUE }
 
enum class  VALUEKIND : UInt64 {
  NONE ,
  VOID_TYPE ,
  GENERIC ,
  GENERIC_ARITHMETIC ,
  SCALAR ,
  INTEGRAL ,
  FLOATING_POINT ,
  ENUM ,
  ENUM_LIST ,
  ENUM_FLAGS ,
  DATA ,
  DATAPTR ,
  NONVIRTUAL_INTERFACE ,
  VIRTUAL_INTERFACE ,
  REF_OR_POINTER ,
  POINTER ,
  STRONG_REFERENCE ,
  COW_REFERENCE ,
  UNIQUE_REFERENCE ,
  ACOW_REFERENCE ,
  LV_REFERENCE ,
  RV_REFERENCE ,
  TUPLE ,
  STRUCT ,
  SIMD ,
  BLOCK ,
  STRIDED_BLOCK ,
  BASEARRAY ,
  BLOCKARRAY ,
  RESULT ,
  DELEGATE ,
  FUNCTION ,
  CONST_QUALIFIED ,
  SOURCE_LEVEL ,
  DEEP_CONSTNESS ,
  INT_SIZE_OR_LESS ,
  ZERO_INITIALIZED ,
  ORDERED ,
  TRIVIALLY_CONSTRUCTIBLE ,
  TRIVIALLY_DESTRUCTIBLE ,
  TRIVIALLY_COPYABLE ,
  TRIVIALLY_EQUATABLE ,
  TRIVIALLY_HASHABLE ,
  OBJECT_REF ,
  VALUE ,
  ELEMENT_TYPE_AS_ARG ,
  NEVER_NULLPTR ,
  SIGNED ,
  GENERIC_INSTANTIATION ,
  ABSTRACT ,
  NAMED ,
  CONTAINER_REF ,
  GENERIC_CONTAINER ,
  RECURSIVE_CONTAINER ,
  RESOLVED_RECURSIVE_CONTAINER ,
  CONTAINER ,
  EMPTY_CONTAINER ,
  VIRTUAL_TUPLE_CONTAINER ,
  STATIC_ARRAY_CONTAINER ,
  ARRAY_CONTAINER ,
  ARRAY ,
  CONTAINER_MASK ,
  NAMED_TUPLE ,
  CONTAINS_RECURSIVE_CONTAINER ,
  CONTAINS_INVALID_TYPE ,
  BUNDLE ,
  MIN_DERIVED_CONTAINER ,
  MIN_ARRAY_CONTAINER ,
  MAX_ARRAY_CONTAINER ,
  COW_MASK ,
  STRONG_MASK ,
  PTR_MASK ,
  CONTAINER_OR_REF ,
  REFERENCE_MASK ,
  ARITHMETIC_MASK ,
  TUPLE_MASK ,
  TUPLE_INHERIT_MASK ,
  POINTER_FLAGS ,
  QUALIFIER_MASK ,
  CONTAINS_MASK
}
 
enum class  COLLECTION_KIND {
  NONE ,
  ARRAY ,
  SET ,
  MAP
}
 
enum class  SUBSYSTEM {
  UNDEFINED ,
  CONSOLE ,
  WINDOWS
}
 
enum class  APPLICATION_URLTYPE {
  STARTUP_DIR ,
  APPLICATION ,
  APP_EXECUTABLE ,
  CORELIBS_DIR ,
  RESOURCE_DIR ,
  TEMP_DIR ,
  PREFS_DIR ,
  GLOBALPREFS_DIR ,
  DESKTOP_DIR ,
  USER_HOME_DIR ,
  USER_DOCUMENTS_DIR ,
  SYSTEM_PROGRAMS_DIR ,
  CURRENT_WORKING_DIR ,
  CURRENT_MODULE_DIR ,
  CURRENT_MODULE_RESOURCE_DIR ,
  PREFS_DIR_STATIC
}
 
enum class  APPLICATIONMODE {
  DONTWAIT ,
  KEEPRUNNING ,
  SHUTDOWN
}
 
enum class  APPLICATIONFEATURE {
  NONE ,
  COMMANDLINE ,
  LIBRARY ,
  UI
}
 
enum class  BASEARRAYFLAGS {
  NONE ,
  MOVEANDCOPYOBJECTS
}
 
enum class  BLOCKARRAYFLAGS {
  NONE ,
  MOVEANDCOPYOBJECTS ,
  NOINSERTERASE ,
  GROW_SLOWLY
}
 
enum class  BURSTTRIE_SORT {
  NONE ,
  LINEAR_SEARCH ,
  BINARY_SEARCH
}
 
enum class  BYTEORDER {
  BIG ,
  LITTLE
}
 
enum class  COLLECTION_RESIZE_FLAGS {
  NONE ,
  ON_SHRINK_KEEP_CAPACITY ,
  ON_SHRINK_FIT_TO_SIZE ,
  ON_GROW_RESERVE_CAPACITY ,
  ON_GROW_FIT_TO_SIZE ,
  ON_GROW_UNINITIALIZED ,
  ON_GROW_UNSPECIFIED ,
  ON_RESIZE_UNSPECIFIED ,
  FIT_TO_SIZE ,
  DEFAULT ,
  POD_UNINITIALIZED
}
 
enum class  CONFIGURATION_CATEGORY {
  REGULAR ,
  DEVELOPMENT ,
  MODULE ,
  EXTENSION ,
  IMPLEMENTATION ,
  NONE ,
  SUBSCRIBER
}
 
enum class  CONFIGURATIONENTRY_ORIGIN {
  APPLICATION ,
  CONFIGURATION ,
  ENVIRONMENT ,
  COMMANDLINE
}
 
enum class  CONFIGURATIONENTRY_STATE {
  UNUSED ,
  INVALIDARGUMENT ,
  USED ,
  OUTOFRANGE
}
 
enum class  CONDITIONTOKENTYPE {
  NONE ,
  ATTRIBUTEID ,
  DYN_ATTRIBUTEID ,
  VARIABLE ,
  CONSTANT ,
  FUNCTION ,
  OPERATOR ,
  PARENTHESIS
}
 
enum class  GETDATAFLAGS {
  NONE ,
  INTENT_ENABLING ,
  INTENT_ENABLING_ISCONNECTED ,
  INTENT_ENABLING_GRAPHNODE ,
  INTENT_ENABLING_HASVALUE ,
  INTENT_GET_TRANSLATEDCHILDREN
}
 
enum class  DBVERSION {
  S22 ,
  R23_CONVERTLIMIT ,
  R23_CONVERTENUM ,
  R23_CONVERTENUM2 ,
  R23_DBVERSIONIDTYPE ,
  CURRENT
}
 
enum class  DESCRIPTIONMESSAGECHECKFLAGS {
  NONE ,
  ENABLED ,
  VISIBLE ,
  CHECKED ,
  SORTSUBMENU
}
 
enum class  LOADDESCRIPTIONMODE {
  COMPLETE ,
  OVERWRITTEN
}
 
enum class  PREPAREHELPERFLAGS {
  NONE ,
  INITIALIZE_READ ,
  INITIALIZE_WRITE ,
  FINALIZE_READ ,
  FINALIZE_WRITE ,
  VALIDATE_STATE
}
 
enum class  DATATYPEBUILDERNAME {
  HUMAN_READABLE ,
  CODE_CPP
}
 
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  DAYOFWEEK {
  MONDAY ,
  TUESDAY ,
  WEDNESDAY ,
  THURSDAY ,
  FRIDAY ,
  SATURDAY ,
  SUNDAY
}
 
enum class  DST : Int16 {
  AUTOMATIC ,
  NOTSET ,
  SET
}
 
enum class  JULIANDATE {
  STANDARD ,
  REDUCED ,
  MODIFIED ,
  LEGACY ,
  TRUNCATED ,
  DUBLIN ,
  LILIAN ,
  RATEDIE ,
  UNIXTIME ,
  MARSSOL
}
 
enum class  HARDWAREBREAKPOINTTYPE {
  CODE ,
  READWRITE ,
  WRITE
}
 
enum class  HARDWAREBREAKPOINTSIZE {
  SIZE1 ,
  SIZE2 ,
  SIZE4 ,
  SIZE8
}
 
enum class  FILEFORMATDETECTIONFLAGS {
  NONE ,
  FASTDETECTION
}
 
enum class  FILEFORMAT_PRIORITY {
  SHIFT_ONE ,
  SHIFT_TEN ,
  FALLBACKFORMAT ,
  GENERALFORMAT ,
  NATIVEFORMAT
}
 
enum class  HASHMAP_ENTRY_LAYOUT {
  HASH_KEY_VALUE ,
  KEY_HASH_VALUE ,
  HASH_VALUE_KEY ,
  HASH_VALUE ,
  KEY_VALUE ,
  VALUE
}
 
enum class  HASHMAP_MODE {
  DEFAULT ,
  SYNCHRONIZED ,
  NO_NONEMPTY_BUCKET_TABLE
}
 
enum class  ASSET_UPDATE_POLICY {
  NEVER ,
  EXPLICIT ,
  IMPLICIT
}
 
enum class  IOARCHIVESTOREMETHOD {
  STORE ,
  DEFLATE
}
 
enum class  IOARCHIVEEXTRACTFLAGS {
  NONE ,
  OVERWRITE_EXISTING_FILE
}
 
enum class  IOBROWSEFLAGS {
  NONE ,
  IS_DIRECTORY ,
  IS_BUNDLE ,
  IS_READONLY ,
  IS_HIDDEN ,
  SUPPORT_REVISIONS ,
  IS_LINK ,
  IS_ENCRYPTED ,
  IS_DELETED ,
  IS_INVISIBLE
}
 
enum class  IOTIMEMODE {
  CREATED ,
  MODIFIED ,
  ACCESSED
}
 
enum class  URLCOMPARE {
  DEFAULT ,
  NORMALIZE ,
  IONORMALIZE ,
  LEGACY ,
  FULL
}
 
enum class  IODETECT {
  ERRORSTATE ,
  NONEXISTENT ,
  UNKNOWN ,
  FILE ,
  LINK ,
  DIRECTORY
}
 
enum class  OPENSTREAMFLAGS {
  NONE ,
  WRITE_DONT_TRUNCATE ,
  ALLOW_SHARED_READ_WRITE_ACCESS ,
  SEEK_TO_END ,
  FULL_DUPLEX ,
  ASK_FOR_REMOVE_WRITE_PROTECTION
}
 
enum class  NORMALIZEFLAGS {
  NONE ,
  SCHEME_BASED ,
  CASE ,
  PATH_SEGMENT ,
  UNICODE_DECOMPOSITION ,
  UNDERLYING ,
  UNDERLYING_RECURSIVE
}
 
enum class  IOATTRIBUTES : UInt {
  NONE ,
  READONLY ,
  HIDDEN ,
  ARCHIVE ,
  LOCKED ,
  OWNER_R ,
  OWNER_W ,
  OWNER_X ,
  GROUP_R ,
  GROUP_W ,
  GROUP_X ,
  PUBLIC_R ,
  PUBLIC_W ,
  PUBLIC_X ,
  RW_MASK ,
  RWX_MASK ,
  MASK_ALL
}
 
enum class  IOSHOWINOSFLAGS {
  NONE ,
  SHOW_IN_EXPLORER ,
  OPEN_IN_EXPLORER
}
 
enum class  JOBGROUPFLAGS {
  DEFAULT ,
  ENQUEUEING_THREAD_WAITS ,
  FINALIZE_ON_WAIT ,
  THREAD_AFFINITY ,
  NO_JOB_DESTRUCTOR
}
 
enum class  STATICJOBGROUPFLAGS {
  DEFAULT ,
  WILL_RUN_FINALIZER ,
  ENQUEUEING_THREAD_WAITS ,
  THREAD_AFFINITY ,
  NO_JOB_DESTRUCTOR
}
 
enum class  STATICJOBARRAYFLAGS {
  DEFAULT ,
  INITIALIZE_LATER
}
 
enum class  JOBQUEUETYPE {
  MAINTHREAD ,
  NONE ,
  LOWESTPRIORITY ,
  LOWPRIORITY ,
  NORMALPRIORITY ,
  SERVICEIO ,
  THREADLESS
}
 
enum class  JOBQUEUEMODE {
  DEFAULT ,
  SPIN_ON_IDLE ,
  SLEEP_ON_IDLE ,
  DETACH_THREADS ,
  PSEUDO_THREADS
}
 
enum class  LEXERSYMBOL : UChar {
  NONE ,
  ILLEGAL ,
  ENDOFFILE ,
  IDENTIFIER ,
  STRING ,
  STRINGCHR ,
  NUMBER ,
  NEWLINE ,
  CURLYBRACKET_OPEN ,
  CURLYBRACKET_CLOSE ,
  PARENTHESE_OPEN ,
  PARENTHESE_CLOSE ,
  SQUAREBRACKET_OPEN ,
  SQUAREBRACKET_CLOSE ,
  SLASH ,
  EQUAL ,
  COMMA ,
  SEMICOLON ,
  COLON ,
  PLUS ,
  TILDE ,
  PREPROCESSOR ,
  MULTIPLY ,
  PIPE ,
  AMPERSAND ,
  OPERATOR
}
 
enum class  LEXERSYMBOLFLAGS {
  NONE ,
  NO_NUMBER ,
  ALLOWSTRINGS ,
  MINUS_OPERATOR
}
 
enum class  LEXERINITFLAGS {
  NONE ,
  NEED_EOL ,
  REWIND_WHEN_DONE ,
  ALLOW_DOLLAR_IDENT ,
  ALLOW_AT_IDENT ,
  NON_ASCII_IS_IDENT ,
  HASH_COMMENTS ,
  ESCAPE_IN_SINGLE_QUOTED ,
  C_ESCAPE_SEQUENCES ,
  DOUBLEQUOTEESCAPE ,
  SPACESCOMPATIBILITY ,
  C4DSTRCOMPATIBILITY
}
 
enum class  ROTATIONORDER {
  ZXYGLOBAL ,
  ZYXGLOBAL ,
  YXZGLOBAL ,
  YZXGLOBAL ,
  XZYGLOBAL ,
  XYZGLOBAL ,
  YXZLOCAL ,
  XYZLOCAL ,
  ZXYLOCAL ,
  XZYLOCAL ,
  YZXLOCAL ,
  ZYXLOCAL
}
 
enum class  MACHINESTATE {
  NONE ,
  CONNECTION_ERROR ,
  ADDED_MANUALLY ,
  AVAILABLE_ZEROCONF ,
  CONNECTED ,
  ALL
}
 
enum class  NULL_RETURN_REASON {
  NULLPTR ,
  MAKE_WRITABLE_FAILED ,
  UNRESOLVED ,
  NULLIMPL
}
 
enum class  NO_VALUE_TYPE { VALUE }
 
enum class  PARALLELFORFLAGS {
  INITTHREADED_FINALIZETHREADED ,
  INITTHREADED_FINALIZESYNC ,
  INITSYNC_FINALIZETHREADED ,
  INITSYNC_FINALIZESYNC ,
  NOINIT_NOFINALIZE
}
 
enum class  PARSERFLAGS {
  NONE ,
  HAS_NO_EOF
}
 
enum class  ACCESSLEVEL {
  UNDEFINED ,
  USERINSTALLATION ,
  ACCOUNT ,
  USER ,
  MACHINE ,
  DEFAULTS ,
  ALL
}
 
enum class  BASESORTFLAGS {
  NONE ,
  MOVEANDCOPYOBJECTS
}
 
enum class  STRINGCONVERSION {
  NONE ,
  ALLOW_MORE_CHARACTERS
}
 
enum class  STRINGCOMPARISON {
  MEMORY ,
  UNICODE_LETTERS ,
  UNICODE_NUMBERS ,
  CASEINSENSITIVE ,
  CASEINSENSITIVE_NUMBERS
}
 
enum class  EXECUTEPROGRAMFLAGS {
  NONE ,
  CAPTURELOGFILE ,
  DONT_DELETE_LOGFILE ,
  HIDE_APPLICATION
}
 
enum class  EXECUTEPROGRAMCALLBACK {
  STARTED ,
  RUNNING ,
  FINISHED ,
  KILLED ,
  CLEANUP_OK ,
  CLEANUP_FAILED
}
 
enum class  WAIT_PROCESS_RESULT {
  FINISHED ,
  RUNNING
}
 
enum class  THREADPRIORITY : Int16 {
  NORMAL ,
  ABOVE ,
  BELOW ,
  LOWEST ,
  BACKGROUND_IDLE
}
 
enum class  WAITMODE {
  DEFAULT ,
  RETURN_ON_CANCEL ,
  PRIVATE_BLOCKING ,
  EXTERNAL_ENQUEUE ,
  DONT_WAIT
}
 
enum class  THREADTYPE {
  MAIN ,
  WORKER ,
  STANDALONE ,
  ALIEN ,
  ASSIMILATED
}
 
enum class  TIMEFORMAT {
  SECONDS ,
  FRAMES ,
  SMPTE ,
  SMPTE_DROPFRAMES
}
 
enum class  NORMALIZATION {
  NFC ,
  NFD ,
  NKDC ,
  NFKD ,
  NFD_HFS
}
 
enum class  CHARACTERTYPE : UChar {
  UNKNOWN ,
  LU ,
  LL ,
  LT ,
  LM ,
  LO ,
  MN ,
  MC ,
  ME ,
  ND ,
  NL ,
  NO ,
  PC ,
  PD ,
  PS ,
  PE ,
  PI ,
  PF ,
  PO ,
  SM ,
  SC ,
  SK ,
  SO ,
  ZS ,
  ZL ,
  ZP ,
  CC ,
  CF ,
  CS ,
  CO ,
  CN
}
 
enum class  BASE_DIMENSION {
  LENGTH ,
  TIME ,
  MASS ,
  TEMPERATURE ,
  AMOUNT_OF_SUBSTANCE ,
  ELECTRIC_CURRENT ,
  LUMINOUS_INTENSITY ,
  ANGLE ,
  SOLID_ANGLE ,
  PRIVATE_COUNT
}
 
enum class  GETBROWSEITERATORFLAGS {
  NONE ,
  NOERRORONOPEN ,
  RESOLVEPATHS
}
 
enum class  CONVERTTOUINAMEFLAGS {
  NONE ,
  NAMEONLY ,
  DIRECTORYONLY ,
  ADDVERSION ,
  CLEARSUFFIX ,
  DONTADDDATABASE
}
 
enum class  URLFILECACHEFLAGS {
  NONE ,
  FORCE_RELOAD
}
 
enum class  COMPARERESULT {
  LESS ,
  EQUAL ,
  GREATER ,
  INCOMPARABLE
}
 
enum class  EQUALITY {
  SHALLOW ,
  DEEP
}
 
enum class  TARGETAUDIENCE {
  DEBUGGER ,
  DEVELOPERS ,
  USERS ,
  ALL
}
 
enum class  WRITEMETA {
  DEFAULT ,
  WARNING ,
  CRITICAL ,
  NONEWLINE ,
  UI_SYNC_DRAW
}
 
enum class  OUTPUT {
  NONE ,
  DIAGNOSTIC ,
  WARNING ,
  CRITICAL ,
  PRETTYPRINT ,
  NOLINEBREAK ,
  HEADER
}
 
enum class  ERROR_OK { VALUE }
 
enum class  ERROR_FAILED { VALUE }
 
enum class  ERROR_TYPE {
  OUT_OF_MEMORY ,
  NULLPTR ,
  ILLEGAL_ARGUMENT ,
  ILLEGAL_STATE ,
  NOT_IMPLEMENTED ,
  UNRESOLVED ,
  UNKNOWN
}
 
enum class  MEMORY_OBSERVER_FLAGS : Int {
  DEFAULT ,
  CLAIM_SHARED_OWNERSHIP ,
  CLAIM_EXCLUSIVE_OWNERSHIP ,
  KEEP_OBSERVER ,
  INVOKE_WITH_UNLOCKED_TARGET
}
 
enum class  MEMORY_OBSERVER_STATE : Int {
  DEFAULT ,
  TARGET_IS_LOCKED ,
  TARGET_HAS_EXCLUSIVE_OWNERSHIP
}
 
enum class  BLOCK_CIPHER_MODE : UInt64 {
  ECB ,
  CBC ,
  PCBC ,
  CFB ,
  OFB ,
  CTR ,
  KEEP_STATE
}
 
enum class  GEOMETRY_TEST_EXACT {
  GEOM_FALSE ,
  GEOM_TRUE ,
  GEOM_PARALLEL ,
  GEOM_ANTIPARALLEL ,
  GEOM_COINCIDENT_PREV ,
  GEOM_COINCIDENT_NEXT ,
  GEOM_COINCIDENT_ALL ,
  GEOM_DEGENERATE ,
  GEOM_INVALID_INPUT
}
 
enum class  LOOP_OVERLAP_STATE {
  INTERSECTING ,
  DISJOINT ,
  A_INSIDE_B ,
  B_INSIDE_A ,
  COINCIDENT ,
  DEGENERATE
}
 
enum class  GRAPH_TYPE {
  CONTINUOS ,
  SPARSE
}
 
enum class  WIRE_MODE : UChar {
  NONE ,
  MIN ,
  NORMAL ,
  PROPAGATION ,
  AUTO_PROPAGATION ,
  MAX ,
  REMOVE ,
  ALL ,
  FLAG0 ,
  FLAG1 ,
  IMPLICIT ,
  ALL_INCLUDING_IMPLICIT ,
  INHERIT ,
  FLAGS_MASK ,
  FULL_MASK ,
  CONNECT_DEFAULT ,
  GETCONNECTIONS_DEFAULT
}
 
enum class  CONNECTION_POSITION {
  SOURCE ,
  CENTER ,
  TARGET
}
 
enum class  NODE_KIND {
  NONE ,
  NODE ,
  INPUTS ,
  OUTPUTS ,
  INPORT ,
  OUTPORT ,
  IN_MASK ,
  OUT_MASK ,
  PORTLIST_MASK ,
  PORT_MASK ,
  ALL_MASK
}
 
enum class  IMAGEHIERARCHY {
  TEXTURE ,
  IMAGE ,
  ALPHA ,
  LAYER ,
  MASK ,
  DEEPIMAGEDATA ,
  MAX_ELEMENTS
}
 
enum class  COLORPROFILEINFO {
  DESCRIPTION ,
  MANUFACTURER ,
  MODEL ,
  COPYRIGHT ,
  NAME ,
  OCIO_CONFIG_PATH
}
 
enum class  COLORCONVERSIONINTENT {
  PERCEPTUAL ,
  RELATIVE_COLORIMETRIC ,
  SATURATION ,
  ABSOLUTE_COLORIMETRIC
}
 
enum class  COLORCONVERSIONFLAGS {
  NONE ,
  BLACKPOINTCOMPENSATION ,
  INVERSE_DIRECTION
}
 
enum class  BLENDPIXELFLAGS { NONE }
 
enum class  CONVERTPIXELFLAGS {
  NONE ,
  FORCECOLORPROFILECONVERSION
}
 
enum class  GETPIXELHANDLERFLAGS {
  NONE ,
  FORCECOLORPROFILECONVERSION ,
  DEEPIMAGE ,
  DONTAPPLYMASK
}
 
enum class  GETPIXELFLAGS {
  NONE ,
  DEEPIMAGE
}
 
enum class  SETPIXELHANDLERFLAGS {
  NONE ,
  FORCECOLORPROFILECONVERSION ,
  DEEPIMAGE
}
 
enum class  SETPIXELFLAGS {
  NONE ,
  DEEPIMAGE
}
 
enum class  LAYERSETMODE {
  LAYERS ,
  LAYERMASKS ,
  ALPHAS ,
  LAYERALPHA ,
  DISABLED
}
 
enum class  MEDIAFORMATTYPE {
  UNDEFINED ,
  IMAGE ,
  ALPHA ,
  LAYERFOLDER ,
  LAYER ,
  LAYERADJUSTMENT ,
  LAYERMASK ,
  MIPMAP ,
  DEEPIMAGEDATA
}
 
enum class  MEDIAALPHATYPE {
  UNDEFINED ,
  PREMULTIPLIED ,
  STRAIGHT
}
 
enum class  RLACHANNELS {
  Z ,
  MATERIALID ,
  NODE_ID ,
  UV ,
  NORMAL ,
  REALPIX ,
  COVERAGE ,
  BG ,
  NODE_RENDER_ID ,
  COLOR ,
  TRANSP ,
  VELOC ,
  WEIGHT ,
  MASK ,
  MAXCOUNT
}
 
enum class  RLAFLAGS {
  NONE ,
  Z ,
  MATERIALID ,
  OBJECTBUFFER ,
  UV ,
  NORMAL ,
  ORIGCOLOR ,
  COVERAGE ,
  BG ,
  OBJECTID ,
  COLOR ,
  TRANSPARENCY ,
  SUBPIXEL_WEIGHT ,
  SUBPIXEL_MASK
}
 
enum class  SELECTIONHANDLERRESULT {
  NONE ,
  STRUCTURE ,
  CONTENT_FLAG ,
  STRUCTURE_WITH_CONTENT ,
  ALL
}
 
enum class  MEDIASESSIONFLAGS {
  NONE ,
  RUNONLYANALYZE ,
  FORCELOAD
}
 
enum class  BLEND_MODES {
  ADD ,
  AVERAGE ,
  COLOR ,
  COLORBURN ,
  COLORDODGE ,
  DARKEN ,
  DARKER ,
  DIFFERENCE ,
  DISSOLVE ,
  DIVIDE ,
  EXCLUSION ,
  FREEZE ,
  GLOW ,
  HARDLIGHT ,
  HARDMIX ,
  HEAT ,
  HUE ,
  HYPOT ,
  LEVR ,
  LIGHTEN ,
  LIGHTER ,
  LINEARBURN ,
  LINEARDODGE ,
  LUMINANCE ,
  MULTIPLY ,
  OVER ,
  OVERLAY ,
  PINLIGHT ,
  REFLECT ,
  SATURATION ,
  SCREEN ,
  SOFTLIGHT ,
  SUBTRACT ,
  VIVIDLIGHT ,
  XOR ,
  PASSFOLDER ,
  STAMP
}
 
enum class  ANIMBLENDSTATE {
  NONE ,
  STARTED ,
  RUNNING ,
  FINISHED ,
  CANCELED
}
 
enum class  FFT_FLAGS {
  NONE ,
  CALC_INVERSE ,
  SUPPRESS_PADDING
}
 
enum class  FFT_SUPPORT {
  NONE ,
  TRANSFORM_1D ,
  TRANSFORM_2D ,
  ALWAYS_PADDING
}
 
enum class  GRADIENT_INTERPOLATION_TYPE {
  CUBICKNOT ,
  CUBICBIAS ,
  SMOOTHKNOT ,
  LINEARKNOT ,
  NONE ,
  EXP_UP ,
  EXP_DOWN ,
  BLEND
}
 
enum class  NURBSCURVE_CONTINUITY {
  OPEN ,
  CLOSED ,
  PERIODIC
}
 
enum class  NURBSCURVE_KNOTMODE {
  CLAMPED_UNIFORM ,
  CLAMPED_CHORDAL ,
  CLAMPED_CENTRIPETAL ,
  UNCLAMPED_UNIFORM ,
  USER_DEFINED
}
 
enum class  SPLINEMAPPER_KNOT_INTERPOLATION_TYPE {
  BEZIER ,
  LINEAR ,
  CUBIC
}
 
enum class  SPLINEMAPPER_KNOT_FLAGS : Int {
  NONE ,
  BREAK_TANGENTS ,
  LOCK_X ,
  LOCK_Y ,
  LOCK_ANGLE ,
  LOCK_LENGTH ,
  KEEPVISUALANGLE ,
  SELECTED
}
 
enum class  SPLINEMAPPER_SPLINE_TYPE {
  SOFT ,
  EASEIN ,
  EASEOUT ,
  EASEEASE ,
  ZERO ,
  UNIFY
}
 
enum class  SPLINEMAPPER_RANGE_STATE {
  NONE ,
  SET ,
  UISET
}
 
enum class  PRIMITIVETYPE {
  NONE ,
  POINT ,
  EDGE ,
  POLYGON
}
 
enum class  METRICUNIT {
  NONE ,
  KM ,
  M ,
  CM ,
  MM ,
  UM ,
  NM ,
  MILE ,
  YARD ,
  FEET ,
  INCH
}
 
enum class  ANGLEUNIT {
  DEGREE ,
  RADIANS
}
 
enum class  CORENODE_PORT_FLAGS {
  NONE ,
  INPUT_WITHOUT_VALUE ,
  OUTPUT_UNUSED
}
 
enum class  PORT_DIR : Int {
  INPUT ,
  OUTPUT ,
  BEGIN ,
  END
}
 
enum class  IOFORMAT {
  DEFAULT ,
  BINARY ,
  BINARY_COMPRESSED ,
  JSON ,
  XML ,
  JSON_STABLE
}
 
enum class  PROFILER_POINT_TYPE {
  NONE ,
  METHOD_ENTER ,
  METHOD_LEAVE ,
  SCOPE_ENTER ,
  SCOPE_LEAVE ,
  DELTA
}
 
enum class  PROFILER_STATE {
  DISABLED ,
  ENABLED_METHOD_SCOPE ,
  ENABLED_ALL
}
 
enum class  PROFILER_CLOCK_MODE {
  NORMAL ,
  SIMULATED
}
 
enum class  SELECTION_MODE : UChar {
  NEW ,
  ADD ,
  SUBTRACT ,
  TOGGLE
}
 
enum class  SELECTION_STATUS : UChar {
  NONE ,
  SELECTED ,
  IMPLICIT
}
 
enum class  REGPARSEMODE {
  MATCH ,
  CONTAINS ,
  STARTS ,
  ENDS
}
 
enum class  HTTPCODE {
  CLOSED ,
  FINISHED ,
  CALL_NEXT_HANDLER ,
  PROXYERROR ,
  OK ,
  POST ,
  MOVED ,
  SYNTAX ,
  AUTH ,
  ACCESS ,
  NOTFOUND ,
  PROXYAUTHENTICATIONREQUIRED ,
  INTERNAL ,
  UNKNOWN ,
  GATEWAYTIMEOUT
}
 
enum class  SOCKETMODE {
  READ ,
  WRITE ,
  LISTEN ,
  CONNECT
}
 
enum class  CONNECTIONMODE {
  UNDEFINED ,
  SEND ,
  READ
}
 
enum class  CONNECTIONTYPE {
  LISTENER ,
  INCOMING ,
  OUTGOING
}
 
enum class  PROTOCOL {
  UNSPEC ,
  IPV4 ,
  IPV6
}
 
enum class  WILDCARD_IPV4_ADDRESS_TYPE { VALUE }
 
enum class  WILDCARD_IPV6_ADDRESS_TYPE { VALUE }
 
enum class  SSLSOCKETTYPE {
  CLIENTCONNECTION ,
  SERVERCONNECTION
}
 
enum class  SSLPROTOCOLVERSION {
  TLS1 ,
  TLS11 ,
  TLS12 ,
  TLS
}
 
enum class  SSLCERTREQUIREMENTS {
  NONE ,
  ISOPTIONAL ,
  ISREQUIRED ,
  MODE ,
  VERIFY_AUTHORITY
}
 
enum class  SSLFILETYPE {
  ASN1 ,
  PEM
}
 
enum class  OAUTHSIGNATUREMETHOD {
  NONE ,
  PLAINTEXT ,
  HMAC_SHA1
}
 
enum class  OAUTHHTTPMETHOD {
  NONE ,
  GET ,
  POST
}
 
enum class  OAUTHERRORCODE {
  NO_USERACCOUNT ,
  SERVICE_NOT_AVAILABLE
}
 
enum class  MEDIA {
  UNKNOWN ,
  TEXT ,
  IMAGE ,
  AUDIO ,
  VIDEO ,
  APP ,
  MULTI
}
 
enum class  MEDIASUB {
  UNKNOWN ,
  HTML ,
  HTML_PLAIN ,
  GIF ,
  JPEG ,
  PNG ,
  TIFF ,
  MPEG ,
  QUICKTIME ,
  X_MSVIDEO ,
  RTF ,
  MAC_BINHEX40 ,
  X_STUFFIT ,
  ZIP ,
  OCTET_STREAM ,
  POSTSCRIPT ,
  PDF
}
 
enum class  SMTPRECEIVERFIELD : UChar {
  TO ,
  CC ,
  BCC
}
 
enum class  HTTPMETHOD {
  GET ,
  POST ,
  PUT ,
  DELETE
}
 
enum class  HTTPREQUESTTYPE {
  UNKNOWN ,
  GET ,
  POST
}
 
enum class  WEBSOCKETSTATE {
  NOT_CONNECTED ,
  CONNECTED ,
  CLOSED ,
  ERROR
}
 
enum class  WEBSOCKETTYPE {
  TEXT ,
  BINARY ,
  CLOSE
}
 
enum class  WEBSOCKET_OPCODE : UChar {
  CONTINUE ,
  TEXT ,
  DATA ,
  CLOSE ,
  PING ,
  PONG ,
  ILLEGAL
}
 
enum class  ZEROCONFACTION {
  NONE ,
  RESOLVE ,
  MONITOR
}
 
enum class  ZEROCONFMACHINESTATE {
  ONLINE ,
  OFFLINE ,
  REMOVED ,
  UPDATE
}
 
enum class  ZEROCONFERROR {
  NONE ,
  UNKNOWN ,
  NOSUCHNAME ,
  NOMEMORY ,
  BADPARAM ,
  BADREFERENCE ,
  BADSTATE ,
  BADFLAGS ,
  UNSUPPORTED ,
  NOTINITIALIZED ,
  ALREADYREGISTERED ,
  NAMECONFLICT ,
  INVALID ,
  FIREWALL ,
  INCOMPATIBLE ,
  BADINTERFACEINDEX ,
  REFUSED ,
  NOSUCHRECORD ,
  NOAUTH ,
  NOSUCHKEY ,
  NATTRAVERSAL ,
  DOUBLENAT ,
  BADTIME ,
  BADSIGNAL ,
  BADKEY ,
  TRANSIENT ,
  SERVICENOTRUNNING ,
  NATPORTMAPPINGUNSUPPORTED ,
  NATPORTMAPPINGDISABLED ,
  NOROUTER ,
  POLLINGMODE
}
 
enum class  NIMBUS_PATH {
  STARTNODE ,
  SOLO ,
  MATERIALENDNODE
}
 
enum class  PyStringEncodings {
  Utf8 ,
  Utf16 ,
  Utf32 ,
  PyDecode
}
 
enum class  OWNERSHIP {
  NORMAL ,
  CALLER ,
  CALLEE ,
  CALLER_BUT_COPY
}
 
enum class  Errno : int {
  _EPERM ,
  _ENOENT ,
  _ESRCH ,
  _EINTR ,
  _EIO ,
  _ENXIO ,
  _E2BIG ,
  _ENOEXEC ,
  _EBADF ,
  _ECHILD ,
  _EAGAIN ,
  _ENOMEM ,
  _EACCES ,
  _EFAULT ,
  _ENOTBLK ,
  _EBUSY ,
  _EEXIST ,
  _EXDEV ,
  _ENODEV ,
  _ENOTDIR ,
  _EISDIR ,
  _EINVAL ,
  _ENFILE ,
  _EMFILE ,
  _ENOTTY ,
  _ETXTBSY ,
  _EFBIG ,
  _ENOSPC ,
  _ESPIPE ,
  _EROFS ,
  _EMLINK ,
  _EPIPE ,
  _EDOM ,
  _ERANGE ,
  _EDEADLK ,
  _ENAMETOOLONG ,
  _ENOLCK ,
  _ENOSYS ,
  _ENOTEMPTY ,
  _ELOOP ,
  _EWOULDBLOCK ,
  _ENOMSG ,
  _EIDRM ,
  _ECHRNG ,
  _EL2NSYNC ,
  _EL3HLT ,
  _EL3RST ,
  _ELNRNG ,
  _EUNATCH ,
  _ENOCSI ,
  _EL2HLT ,
  _EBADE ,
  _EBADR ,
  _EXFULL ,
  _ENOANO ,
  _EBADRQC ,
  _EBADSLT ,
  _EDEADLOCK ,
  _EBFONT ,
  _ENOSTR ,
  _ENODATA ,
  _ETIME ,
  _ENOSR ,
  _ENONET ,
  _ENOPKG ,
  _EREMOTE ,
  _ENOLINK ,
  _EADV ,
  _ESRMNT ,
  _ECOMM ,
  _EPROTO ,
  _EMULTIHOP ,
  _EDOTDOT ,
  _EBADMSG ,
  _EOVERFLOW ,
  _ENOTUNIQ ,
  _EBADFD ,
  _EREMCHG ,
  _ELIBACC ,
  _ELIBBAD ,
  _ELIBSCN ,
  _ELIBMAX ,
  _ELIBEXEC ,
  _EILSEQ ,
  _ERESTART ,
  _ESTRPIPE ,
  _EUSERS ,
  _ENOTSOCK ,
  _EDESTADDRREQ ,
  _EMSGSIZE ,
  _EPROTOTYPE ,
  _ENOPROTOOPT ,
  _EPROTONOSUPPORT ,
  _ESOCKTNOSUPPORT ,
  _EOPNOTSUPP ,
  _EPFNOSUPPORT ,
  _EAFNOSUPPORT ,
  _EADDRINUSE ,
  _EADDRNOTAVAIL ,
  _ENETDOWN ,
  _ENETUNREACH ,
  _ENETRESET ,
  _ECONNABORTED ,
  _ECONNRESET ,
  _ENOBUFS ,
  _EISCONN ,
  _ENOTCONN ,
  _ESHUTDOWN ,
  _ETOOMANYREFS ,
  _ETIMEDOUT ,
  _ECONNREFUSED ,
  _EHOSTDOWN ,
  _EHOSTUNREACH ,
  _EALREADY ,
  _EINPROGRESS ,
  _ESTALE ,
  _EUCLEAN ,
  _ENOTNAM ,
  _ENAVAIL ,
  _EISNAM ,
  _EREMOTEIO ,
  _EDQUOT ,
  _ENOMEDIUM ,
  _EMEDIUMTYPE ,
  _ECANCELED ,
  _ENOKEY ,
  _EKEYEXPIRED ,
  _EKEYREVOKED ,
  _EKEYREJECTED ,
  _EOWNERDEAD ,
  _ENOTRECOVERABLE
}
 
enum class  CONTAINS : int {
  _FOUND ,
  _NOTFOUND ,
  _ERROR
}
 
enum class  VMSETTINGS {
  MOVE_ERRORS_TO_RESULT ,
  USE_AUTO_GIL
}
 
enum class  VMINITSETTINGS {
  CPYTHON_ADDITIONAL_SYS_PATH ,
  CPYTHON_INTERPRETERFLAGS ,
  CPYTHON_SUBINTERPRETER ,
  PYPY_EXECUTABLE
}
 
enum class  ERRORHANDLING {
  PRINT ,
  CLEAR ,
  REDIRECT
}
 
enum class  DEFAULTRUNTIME {
  NONE ,
  DEBUG_3_VS2015 ,
  RELEASE_3_VS2015 ,
  DEBUG_3 ,
  RELEASE_3 ,
  DEFAULT_3 ,
  DEFAULT
}
 
enum class  VOLUMESAMPLER {
  NEAREST ,
  LINEAR ,
  QUADRATIC
}
 
enum class  ITERATORTYPE {
  ALL ,
  ON ,
  OFF
}
 
enum class  TREEVOXELLEVEL {
  ROOT ,
  TWO ,
  THREE ,
  LEAF
}
 
enum class  VOLUME_RAY_TYPE {
  WORLD_SPACE ,
  INDEX_SPACE
}
 
enum class  POLYGONCONVERSIONFLAGS {
  NONE ,
  UNSIGNED_DISTANCE_FIELD ,
  DISABLE_INTERSECTING_VOXEL_REMOVAL ,
  DISABLE_RENORMALIZATION ,
  DISABLE_NARROW_BAND_TRIMMING
}
 
enum class  MIXVECTORTYPE {
  NONE ,
  NORMAL ,
  ADD ,
  SUBTRACT ,
  CROSS
}
 
enum class  SDFFILTERTYPE {
  NONE ,
  GAUSSIAN ,
  DILATE ,
  ERODE ,
  MEANVALUE ,
  MEDIANVALUE ,
  MEANCURVATURE ,
  LAPLACIANFLOW ,
  RENORMALIZE ,
  OPEN ,
  CLOSE ,
  TRACK ,
  RESIZE
}
 
enum class  FILTERTYPE {
  NONE ,
  GAUSSIAN ,
  MEANVALUE ,
  MEDIANVALUE ,
  ADD ,
  REMAP ,
  CURVEREMAP ,
  MULTIPLY ,
  ABS ,
  INVERT
}
 
enum class  VECTORFILTERTYPE {
  NONE ,
  GAUSSIAN ,
  MEANVALUE ,
  MEDIANVALUE ,
  CURL ,
  NORMALIZE ,
  INVERT ,
  SCALE ,
  ROTATE
}
 
enum class  FILTERACCURACY {
  NONE ,
  FIRST ,
  SECOND ,
  THIRD ,
  WENO5 ,
  HJWENO5
}
 
enum class  RESAMPLEINTERPOLATIONTYPE {
  NONE ,
  NEAREST ,
  LINEAR ,
  QUADRATIC
}
 

Functions

 MAXON_REGISTRY (Class< AutoWeightRef >, AutoWeightAlgos, "net.maxon.animation.registry.autoweights")
 
enum maxon::COMMAND_ASSET_STATE MAXON_ENUM_FLAGS (COMMAND_ASSET_STATE)
 
 MAXON_DATATYPE (AssetDatabaseStruct, "net.maxon.datatype.assetdatabasestruct")
 
 MAXON_DATATYPE (DragAndDropDataAssetArray, "net.maxon.datatype.draganddropdataassetarray")
 
class DataDescription MAXON_FORWARD ("maxon/datadescription.h")
 
class DataDescriptionDefinition MAXON_FORWARD ("maxon/datadescriptiondefinition.h")
 
enum maxon::ASSETLICENSETYPE UInt64 MAXON_ENUM_FLAGS (ASSETLICENSETYPE)
 
 MAXON_DATATYPE (AssetDependencyStruct, "net.maxon.datatype.asset.dependencystruct")
 
class OutputStreamRef MAXON_FORWARD ("maxon/iostreams.h")
 
 MAXON_DECLARATION (Class< AssetType >, AssetTypeBaseComponent, "net.maxon.component.assettypebase")
 
 MAXON_REGISTRY (AssetType, AssetTypes, "net.maxon.registry.assettypes")
 
enum maxon::ASSET_FIND_MODE MAXON_ENUM_FLAGS (ASSET_FIND_MODE)
 
 MAXON_DECLARATION (ComponentDescriptor, AssetBaseComponent, "net.maxon.component.assetbase")
 
enum maxon::REPOSITORYINDEXSTATE MAXON_ENUM_LIST (REPOSITORYINDEXSTATE)
 
 MAXON_REGISTRY (BuiltinAssetLoader, BuiltinAssetLoaders, "net.maxon.registry.builtinassetloaders")
 
 MAXON_REGISTRY (Class< AssetRepositoryRef >, AssetRepositoryTypes, "net.maxon.registry.assetrepositorytypes")
 
 MAXON_DECLARATION (Class< AssetRepositoryRef >, AssetRepositoryDecoratorBaseClass, "net.maxon.class.assetrepositorydecoratorbase")
 
 MAXON_DECLARATION (Class< AssetRepositoryRef >, WeakAssetRepositoryDecoratorClass, "net.maxon.class.weakassetrepositorydecorator")
 
Url GetAssetUrl (const DndAsset &asset)
 
Result< void > UpdateAssetUsage (const AssetDescription &asset, Bool incCount=true, Bool updateDate=true)
 
Result< IdAndVersion > IdToIdAndVersion (const Id &id)
 
Result< Id > IdAndVersionToId (const IdAndVersion &assetId)
 
Result< Tuple< AssetRepositoryRef, IdAndVersion, Bool > > IdToIdAndVersionWithRepository (const Id &id, const AssetRepositoryRef &lookupRepository)
 
Result< Id > IdAndVersionToIdWithRepository (const IdAndVersion &assetId, const AssetRepositoryRef &repository)
 
 MAXON_DATATYPE (StoreAssetStruct, "net.maxon.datatype.storeassetstruct")
 
 MAXON_DATATYPE (ResolveAssetDependenciesStruct, "net.maxon.datatype.resolveassetdependenciesstruct")
 
 MAXON_DATATYPE (AddAssetDepencendyStruct, "net.maxon.datatype.addassetdepencendystruct")
 
 MAXON_DECLARATION (Class< BasePresetAssetType >, AssetTypeBasePresetClass, "net.maxon.class.assettypepresetbase")
 
 MAXON_ATTRIBUTE (void, AssetCategoryUncategorized, "net.maxon.assetcategory.uncategorized")
 
 MAXON_ATTRIBUTE (void, AssetCategoryWatchFolders, "category@5846c0689c0248cfa54bffed866571ce")
 
template<typename T , typename CALLBACK >
Result< T > GetDerivedMetaData (const AssetDescription &asset, const InternedId &metaId, const CString &externalStamp, CALLBACK &&callback)
 
 MAXON_DECLARATION (LazyLanguageStringDataDescriptionDefinition, LazyLanguageStringDataDescriptionDefinitionClass, "net.maxon.class.lazylanguagestringdatadescriptiondefinition")
 
 MAXON_DECLARATION (LazyLanguageDictionary, LazyLanguageDictionaryClass, "net.maxon.class.lazylanguagedictionary")
 
 MAXON_ATTRIBUTE (void, AssetCategorySmartSearch, "net.maxon.asset.category.smartsearches")
 
enum maxon::OUTPUTLOCATION MAXON_ENUM_FLAGS (OUTPUTLOCATION)
 
enum maxon::ASSETINSERTOBJECTMODE MAXON_ENUM_LIST (ASSETINSERTOBJECTMODE)
 
enum maxon::GENERATESCENEPREVIEWIMAGEFLAGS MAXON_ENUM_FLAGS (GENERATESCENEPREVIEWIMAGEFLAGS)
 
enum maxon::OPENSAVEASSETDIALOGFLAGS MAXON_ENUM_FLAGS (OPENSAVEASSETDIALOGFLAGS)
 
enum maxon::ASSETPOPUPOPTIONS MAXON_ENUM_FLAGS (ASSETPOPUPOPTIONS)
 
enum maxon::MASTERFILTER MAXON_ENUM_LIST (MASTERFILTER)
 
 MAXON_DATATYPE (CommandGetStateDelegate, "net.maxon.hybrid.datatype.commandgetstate")
 
 MAXON_REGISTRY (CommandGetStateDelegate, CommandGetStateDelegates, "net.maxon.hybrid.command.getstates")
 
 MAXON_DATATYPE (CreateMaterialWithDataDelegate, "net.maxon.hybrid.datatype.creatematerialwithdatadelegate")
 
 MAXON_REGISTRY (CreateMaterialWithDataDelegate, CreateMaterialWithDataDelegates, "net.maxon.hybrid.command.creatematerialwithdata")
 
 MAXON_DATATYPE (CreateDefaultMaterialDelegate, "net.maxon.hybrid.datatype.createdefaultmaterialdelegate")
 
 MAXON_REGISTRY (CreateDefaultMaterialDelegate, CreateDefaultMaterialDelegates, "net.maxon.hybrid.command.createdefaultmaterials")
 
Result< PythonElementBaseRef > GetPyElemFromNode (FactoryInterface::ConstPtr factory, BaseList2D *bl)
 
 MAXON_DECLARATION (Class< PythonElementBaseRef >, PythonElementBaseClass, "net.maxon.class.python_element.base")
 
 MAXON_DECLARATION (PyBaseElementFactoryType, PyBaseElementFactory, "net.maxon.factory.python_element.base")
 
 MAXON_DECLARATION (Class< PythonElementEmbeddedRef >, PythonEmbeddedClass, "net.maxon.class.python_element.embedded")
 
 MAXON_DECLARATION (PyEmbeddedElementFactoryType, PyEmbeddedElementFactory, "net.maxon.factory.python_element.embedded")
 
 MAXON_DECLARATION (Class< PythonElementBaseRef >, PythonDirectoryClass, "net.maxon.class.python_element.directory")
 
 MAXON_DECLARATION (PyDirectoryElementFactoryType, PyDirectoryElementFactory, "net.maxon.factory.python_element.directory")
 
 MAXON_DECLARATION (Class< PythonElementScriptRef >, PythonScriptClass, "net.maxon.class.python_element.script")
 
 MAXON_DECLARATION (PyScriptElementFactoryType, PyScriptElementFactory, "net.maxon.factory.python_element.script")
 
 MAXON_REGISTRY (Class< PythonBaseList2DDetectorRef >, PyBaseList2DDetectors, "net.maxon.registry.python_baselist2d_detector")
 
 MAXON_DECLARATION (Class< PyElementManagerRef >, PyElementManager, "net.maxon.py_element_manager_interface")
 
 MAXON_REGISTRY (UiConversion, UiConversions, "net.maxon.image.registry.uiconversions")
 
enum maxon::COMMANDSTATE MAXON_ENUM_LIST (COMMANDSTATE)
 
enum maxon::COMMANDRESULT MAXON_ENUM_LIST (COMMANDRESULT)
 
enum maxon::INTERACTIONTYPE MAXON_ENUM_LIST (INTERACTIONTYPE, "net.maxon.command.interationtype")
 
 MAXON_DATATYPE (CommandCacheData, "net.maxon.datatype.commandcachedata")
 
 MAXON_DATATYPE (CommandCacheMap, "net.maxon.datatype.commandcachemap")
 
 MAXON_REGISTRY (Class< CommandDataRef >, CommandDataClasses, "net.maxon.command.registry.commanddataclasses")
 
 MAXON_REGISTRY (Class< LegacyCommandDataRef >, LegacyCommandDataClasses, "net.maxon.command.registry.legacycommanddataclasses")
 
 MAXON_REGISTRY (CommandClass, CommandClasses, "net.maxon.command.registry.commandclasses")
 
 MAXON_REGISTRY (LegacyCommandClass, LegacyCommand, "net.maxon.command.registry.legacycommandclass")
 
 MAXON_REGISTRY (MigratedCommandClass, MigratedCommand, "net.maxon.command.registry.migratedcommandclass")
 
 MAXON_REGISTRY (CommandInteractionClass, CommandInteraction, "net.maxon.command.registry.commandinteractionclass")
 
 MAXON_REGISTRY (CommandDescriptionClass, CommandDescription, "net.maxon.command.registry.commanddescriptionclass")
 
 MAXON_REGISTRY (CommandConversionClass, CommandConversionClasses, "net.maxon.command.registry.commandconversionclasses")
 
 MAXON_REGISTRY (Class< CommandCacheRef >, CommandCacheClasses, "net.maxon.command.registry.commandcacheclasses")
 
 MAXON_DECLARATION (Class< CommandObserverRef >, CommandObserverObjectClass, "net.maxon.command.class.observer")
 
 MAXON_DATATYPE (InvocationState, "net.maxon.datatype.command.invokationstate")
 
template<typename T >
std::false_type TestForBeginFunction (OverloadRank0)
 
template<typename T >
std::false_type TestForEndFunction (OverloadRank0)
 
template<typename ITERATOR , typename SENTINEL , typename ... ARGS, typename = typename std::enable_if<!IsIterable<ITERATOR>::value>::type>
auto ConstructElements (ITERATOR first, SENTINEL sentinel, const ARGS &... args) -> ITERATOR
 
template<typename ITERABLE , typename ... ARGS, typename = typename std::enable_if<IsIterable<ITERABLE>::value>::type>
auto ConstructElements (ITERABLE &&iterable, const ARGS &... args) -> decltype(begin(iterable))
 
template<typename ITERATOR , typename SENTINEL , typename = typename std::enable_if<!IsIterable<ITERATOR>::value>::type>
auto DestructElements (ITERATOR first, SENTINEL sentinel) -> ITERATOR
 
template<typename ITERABLE , typename = typename std::enable_if<IsIterable<ITERABLE>::value>::type>
auto DestructElements (ITERABLE &&iterable) -> decltype(begin(iterable))
 
template<typename ITERATOR , typename SENTINEL , typename DEST_ITERATOR >
auto Copy (ITERATOR first, SENTINEL sentinel, DEST_ITERATOR dest) -> Result< DEST_ITERATOR >
 
template<typename ITERABLE , typename DEST_ITERATOR >
auto Copy (const ITERABLE &iterable, DEST_ITERATOR dest) -> Result< DEST_ITERATOR >
 
template<typename ITERATOR , typename SENTINEL , typename DEST_ITERATOR , typename PREDICATE >
auto CopyIf (ITERATOR first, SENTINEL sentinel, DEST_ITERATOR dest, PREDICATE pred) -> Result< DEST_ITERATOR >
 
template<typename ITERABLE , typename DEST_ITERATOR , typename PREDICATE >
auto CopyIf (const ITERABLE &iterable, DEST_ITERATOR dest, PREDICATE pred) -> Result< DEST_ITERATOR >
 
template<typename ITERATOR , typename SENTINEL , typename DEST_ITERATOR >
auto CopyToUninitialized (ITERATOR first, SENTINEL sentinel, DEST_ITERATOR dest) -> Result< DEST_ITERATOR >
 
template<typename ITERABLE , typename DEST_ITERATOR >
auto CopyToUninitialized (const ITERABLE &iterable, DEST_ITERATOR dest) -> Result< DEST_ITERATOR >
 
template<typename ITERATOR , typename SENTINEL , typename DEST_ITERATOR , typename PREDICATE >
auto CopyToUninitializedIf (ITERATOR first, SENTINEL sentinel, DEST_ITERATOR dest, PREDICATE pred) -> Result< DEST_ITERATOR >
 
template<typename ITERABLE , typename DEST_ITERATOR , typename PREDICATE >
auto CopyToUninitializedIf (const ITERABLE &iterable, DEST_ITERATOR dest, PREDICATE pred) -> Result< DEST_ITERATOR >
 
enum maxon::MOVE_MODE MAXON_ENUM_LIST (MOVE_MODE)
 
template<MOVE_MODE MODE = MOVE_MODE::KEEP_SOURCE, typename ITERATOR , typename SENTINEL , typename DEST_ITERATOR >
auto Move (ITERATOR first, SENTINEL sentinel, DEST_ITERATOR dest) -> DEST_ITERATOR
 
template<MOVE_MODE MODE = MOVE_MODE::KEEP_SOURCE, typename ITERABLE , typename DEST_ITERATOR >
auto Move (ITERABLE &&iterable, DEST_ITERATOR dest) -> DEST_ITERATOR
 
template<MOVE_MODE MODE = MOVE_MODE::KEEP_SOURCE, typename ITERATOR , typename SENTINEL , typename DEST_ITERATOR , typename PREDICATE >
auto MoveIf (ITERATOR first, SENTINEL sentinel, DEST_ITERATOR dest, PREDICATE pred) -> DEST_ITERATOR
 
template<MOVE_MODE MODE = MOVE_MODE::KEEP_SOURCE, typename ITERABLE , typename DEST_ITERATOR , typename PREDICATE >
auto MoveIf (ITERABLE &&iterable, DEST_ITERATOR dest, PREDICATE pred) -> DEST_ITERATOR
 
template<MOVE_MODE MODE = MOVE_MODE::KEEP_SOURCE, typename ITERATOR , typename SENTINEL , typename DEST_ITERATOR >
auto MoveToUninitialized (ITERATOR first, SENTINEL sentinel, DEST_ITERATOR dest) -> DEST_ITERATOR
 
template<MOVE_MODE MODE = MOVE_MODE::KEEP_SOURCE, typename ITERABLE , typename DEST_ITERATOR >
auto MoveToUninitialized (ITERABLE &&iterable, DEST_ITERATOR dest) -> DEST_ITERATOR
 
template<MOVE_MODE MODE = MOVE_MODE::KEEP_SOURCE, typename ITERATOR , typename SENTINEL , typename DEST_ITERATOR , typename PREDICATE >
auto MoveToUninitializedIf (ITERATOR first, SENTINEL sentinel, DEST_ITERATOR dest, PREDICATE pred) -> DEST_ITERATOR
 
template<MOVE_MODE MODE = MOVE_MODE::KEEP_SOURCE, typename ITERABLE , typename DEST_ITERATOR , typename PREDICATE >
auto MoveToUninitializedIf (ITERABLE &&iterable, DEST_ITERATOR dest, PREDICATE pred) -> DEST_ITERATOR
 
template<typename ITERABLE , typename T >
auto Fill (ITERABLE &&iterable, const T &value) -> decltype(begin(iterable))
 
template<typename ITERATOR , typename SENTINEL , typename GENERATOR >
auto Generate (ITERATOR first, SENTINEL sentinel, GENERATOR gen) -> ITERATOR
 
template<typename ITERABLE , typename GENERATOR >
auto Generate (ITERABLE &&iterable, GENERATOR gen) -> decltype(begin(iterable))
 
template<typename ITERATOR , typename SENTINEL , typename PREDICATE >
Bool AllOf (ITERATOR first, SENTINEL sentinel, PREDICATE pred)
 
template<typename ITERABLE , typename PREDICATE >
Bool AllOf (const ITERABLE &iterable, PREDICATE pred)
 
template<typename ITERATOR , typename SENTINEL , typename PREDICATE >
Bool AnyOf (ITERATOR first, SENTINEL sentinel, PREDICATE pred)
 
template<typename ITERABLE , typename PREDICATE >
Bool AnyOf (const ITERABLE &iterable, PREDICATE pred)
 
template<typename ITERATOR , typename SENTINEL , typename PREDICATE >
Bool NoneOf (ITERATOR first, SENTINEL sentinel, PREDICATE pred)
 
template<typename ITERABLE , typename PREDICATE >
Bool NoneOf (const ITERABLE &iterable, PREDICATE pred)
 
template<typename ITERATOR1 , typename SENTINEL1 , typename ITERATOR2 , typename SENTINEL2 >
Bool Equal (ITERATOR1 first1, SENTINEL1 sentinel1, ITERATOR2 first2, SENTINEL2 sentinel2)
 
template<typename ITERABLE1 , typename ITERABLE2 >
Bool Equal (const ITERABLE1 &iterable1, const ITERABLE2 &iterable2)
 
template<typename ITERATOR1 , typename SENTINEL1 , typename ITERATOR2 , typename SENTINEL2 , typename COMPARE >
Bool Equal (ITERATOR1 first1, SENTINEL1 sentinel1, ITERATOR2 first2, SENTINEL2 sentinel2, COMPARE comp)
 
template<typename ITERABLE1 , typename ITERABLE2 , typename COMPARE >
Bool Equal (const ITERABLE1 &iterable1, const ITERABLE2 &iterable2, COMPARE comp)
 
template<typename ITERATOR1 , typename SENTINEL1 , typename ITERATOR2 , typename SENTINEL2 >
auto Mismatch (ITERATOR1 first1, SENTINEL1 sentinel1, ITERATOR2 first2, SENTINEL2 sentinel2) -> Optional< Pair< ITERATOR1, ITERATOR2 >>
 
template<typename ITERABLE1 , typename ITERABLE2 >
auto Mismatch (ITERABLE1 &&iterable1, ITERABLE2 &&iterable2) -> Optional< Pair< decltype(begin(iterable1)), decltype(begin(iterable2))>>
 
template<typename ITERATOR1 , typename SENTINEL1 , typename ITERATOR2 , typename SENTINEL2 , typename COMPARE >
auto Mismatch (ITERATOR1 first1, SENTINEL1 sentinel1, ITERATOR2 first2, SENTINEL2 sentinel2, COMPARE comp) -> Optional< Pair< ITERATOR1, ITERATOR2 >>
 
template<typename ITERABLE1 , typename ITERABLE2 , typename COMPARE >
auto Mismatch (ITERABLE1 &&iterable1, ITERABLE2 &&iterable2, COMPARE comp) -> Optional< Pair< decltype(begin(iterable1)), decltype(begin(iterable2))>>
 
template<typename ITERATOR , typename PREDICATE >
auto Partition (ITERATOR first, ITERATOR last, PREDICATE pred) -> ITERATOR
 
template<typename ITERATOR , typename SENTINEL , typename PREDICATE >
auto Partition (ITERATOR first, SENTINEL sentinel, PREDICATE pred) -> ITERATOR
 
template<typename ITERABLE , typename PREDICATE >
auto Partition (ITERABLE &&iterable, PREDICATE pred) -> decltype(begin(iterable))
 
template<typename ITERATOR , typename PREDICATE >
Bool IsPartitioned (ITERATOR first, ITERATOR last, PREDICATE pred)
 
template<typename ITERATOR , typename SENTINEL , typename PREDICATE >
Bool IsPartitioned (ITERATOR first, SENTINEL sentinel, PREDICATE pred)
 
template<typename ITERABLE , typename PREDICATE >
Bool IsPartitioned (const ITERABLE &iterable, PREDICATE pred)
 
template<typename ITERABLE >
auto Reverse (ITERABLE &&iterable) -> decltype(begin(iterable))
 
template<typename ITERATOR , typename T >
auto LowerBound (ITERATOR first, ITERATOR last, const T &value) -> ITERATOR
 
template<typename ITERATOR , typename T , typename COMPARE >
auto LowerBound (ITERATOR first, ITERATOR last, const T &value, COMPARE comp) -> ITERATOR
 
template<typename ITERATOR , typename SENTINEL , typename T >
auto LowerBound (ITERATOR first, SENTINEL sentinel, const T &value) -> ITERATOR
 
template<typename ITERATOR , typename SENTINEL , typename T , typename COMPARE >
auto LowerBound (ITERATOR first, SENTINEL sentinel, const T &value, COMPARE comp) -> ITERATOR
 
template<typename ITERABLE , typename T >
auto LowerBound (ITERABLE &&iterable, const T &value) -> decltype(begin(iterable))
 
template<typename ITERABLE , typename T , typename COMPARE >
auto LowerBound (ITERABLE &&iterable, const T &value, COMPARE comp) -> decltype(begin(iterable))
 
template<typename ITERATOR , typename T >
auto UpperBound (ITERATOR first, ITERATOR last, const T &value) -> ITERATOR
 
template<typename ITERATOR , typename T , typename COMPARE >
auto UpperBound (ITERATOR first, ITERATOR last, const T &value, COMPARE comp) -> ITERATOR
 
template<typename ITERATOR , typename SENTINEL , typename T >
auto UpperBound (ITERATOR first, SENTINEL sentinel, const T &value) -> ITERATOR
 
template<typename ITERATOR , typename SENTINEL , typename T , typename COMPARE >
auto UpperBound (ITERATOR first, SENTINEL sentinel, const T &value, COMPARE comp) -> ITERATOR
 
template<typename ITERABLE , typename T >
auto UpperBound (ITERABLE &&iterable, const T &value) -> decltype(begin(iterable))
 
template<typename ITERABLE , typename T , typename COMPARE >
auto UpperBound (ITERABLE &&iterable, const T &value, COMPARE comp) -> decltype(begin(iterable))
 
template<typename ITERATOR , typename T >
auto BinarySearch (ITERATOR first, ITERATOR last, const T &value) -> Optional< ITERATOR >
 
template<typename ITERATOR , typename SENTINEL , typename T >
auto BinarySearch (ITERATOR first, SENTINEL sentinel, const T &value) -> Optional< ITERATOR >
 
template<typename ITERATOR , typename T , typename COMPARE >
auto BinarySearch (ITERATOR first, ITERATOR last, const T &value, COMPARE comp) -> Optional< ITERATOR >
 
template<typename ITERATOR , typename SENTINEL , typename T , typename COMPARE >
auto BinarySearch (ITERATOR first, SENTINEL sentinel, const T &value, COMPARE comp) -> Optional< ITERATOR >
 
template<typename ITERABLE , typename T >
auto BinarySearch (ITERABLE &&iterable, const T &value) -> decltype(begin(iterable))
 
template<typename ITERABLE , typename T , typename COMPARE >
auto BinarySearch (ITERABLE &&iterable, const T &value, COMPARE comp) -> decltype(begin(iterable))
 
template<typename ITERATOR >
auto Rotate (ITERATOR first, ITERATOR last, ITERATOR newFirst) -> ITERATOR
 
template<typename ITERABLE , typename ITERATOR >
auto Rotate (ITERABLE &&iterable, ITERATOR newFirst) -> ITERATOR
 
template<typename ITERATOR , typename SENTINEL >
auto Rotate (ITERATOR first, SENTINEL sentinel, ITERATOR newFirst) -> ITERATOR
 
template<typename ITERATOR , typename SENTINEL , typename T >
Int Count (ITERATOR first, SENTINEL sentinel, const T &value)
 
template<typename ITERABLE , typename T >
Int Count (ITERABLE &&iterable, const T &value)
 
template<typename ITERATOR , typename SENTINEL , typename PREDICATE >
Int CountIf (ITERATOR first, SENTINEL sentinel, PREDICATE pred)
 
template<typename ITERABLE , typename PREDICATE >
auto CountIf (const ITERABLE &iterable, PREDICATE pred) -> Int
 
template<typename ITERATOR , typename SENTINEL , typename = typename std::enable_if<!IsIterable<ITERATOR>::value>::type>
auto Unique (ITERATOR first, SENTINEL sentinel) -> ITERATOR
 
template<typename ITERABLE >
auto Unique (ITERABLE &&iterable) -> decltype(begin(iterable))
 
template<typename ITERATOR , typename SENTINEL , typename COMPARE >
auto Unique (ITERATOR first, SENTINEL sentinel, COMPARE comp) -> ITERATOR
 
template<typename ITERABLE , typename COMPARE , typename = typename std::enable_if<IsIterable<ITERABLE>::value>::type>
auto Unique (ITERABLE &&iterable, COMPARE comp) -> decltype(begin(iterable))
 
template<typename ITERATOR , typename SENTINEL , typename T >
auto Remove (ITERATOR first, SENTINEL sentinel, const T &value) -> ITERATOR
 
template<typename ITERABLE , typename T >
auto Remove (ITERABLE &&iterable, const T &value) -> decltype(begin(iterable))
 
template<typename ITERABLE , typename PREDICATE >
auto RemoveIf (ITERABLE &&iterable, PREDICATE pred) -> decltype(begin(iterable))
 
template<typename ITERATOR , typename SENTINEL , typename T >
auto Replace (ITERATOR first, SENTINEL sentinel, const T &oldValue, const T &newValue) -> ITERATOR
 
template<typename ITERABLE , typename T >
auto Replace (ITERABLE &&iterable, const T &oldValue, const T &newValue) -> decltype(begin(iterable))
 
template<typename ITERATOR , typename SENTINEL , typename PREDICATE , typename T >
auto ReplaceIf (ITERATOR first, SENTINEL sentinel, PREDICATE pred, const T &newValue) -> ITERATOR
 
template<typename ITERABLE , typename PREDICATE , typename T >
auto ReplaceIf (ITERABLE &&iterable, PREDICATE pred, const T &newValue) -> decltype(begin(iterable))
 
template<typename ITERATOR , typename SENTINEL , typename V , typename BINARYOP >
V Fold (ITERATOR first, SENTINEL sentinel, V initialValue, BINARYOP op)
 
template<typename ITERABLE , typename V , typename BINARYOP >
V Fold (const ITERABLE &iterable, const V &intitialValue, BINARYOP op)
 
template<typename ITERATOR , typename SENTINEL >
auto MinElement (ITERATOR first, SENTINEL sentinel) -> Optional< ITERATOR >
 
template<typename ITERATOR , typename SENTINEL , typename COMPARE >
auto MinElement (ITERATOR first, SENTINEL sentinel, COMPARE comp) -> Optional< ITERATOR >
 
template<typename ITERABLE >
auto MinElement (ITERABLE &&iterable) -> Optional< decltype(begin(iterable))>
 
template<typename ITERABLE , typename COMPARE >
auto MinElement (ITERABLE &&iterable, COMPARE comp) -> Optional< decltype(begin(iterable))>
 
template<typename ITERATOR , typename SENTINEL >
auto MaxElement (ITERATOR first, SENTINEL sentinel) -> Optional< ITERATOR >
 
template<typename ITERATOR , typename SENTINEL , typename COMPARE >
auto MaxElement (ITERATOR first, SENTINEL sentinel, COMPARE comp) -> Optional< ITERATOR >
 
template<typename ITERABLE >
auto MaxElement (ITERABLE &&iterable) -> Optional< decltype(begin(iterable))>
 
template<typename ITERABLE , typename COMPARE >
auto MaxElement (ITERABLE &&iterable, COMPARE comp) -> Optional< decltype(begin(iterable))>
 
template<typename ITERATOR >
Int GetSequenceLength (ITERATOR first, ITERATOR last)
 
template<typename ITERATOR , typename SENTINEL >
Int GetSequenceLength (ITERATOR first, SENTINEL sentinel)
 
template<typename ITERABLE >
Int GetSequenceLength (const ITERABLE &iterable)
 
enum maxon::NO_MATCH_TYPE MAXON_ENUM_LIST (NO_MATCH_TYPE)
 
template<typename INDEXABLE , typename MATCHER >
static auto CountIfMatch (INDEXABLE &&indexable, MATCHER matcher) -> Match< Int >
 
template<typename ITERATOR , typename SENTINEL , typename MATCHER >
auto LinearSearch (ITERATOR first, SENTINEL sentinel, MATCHER matcher) -> Match< ITERATOR >
 
template<typename ITERABLE , typename MATCHER >
auto LinearSearch (ITERABLE &&iterable, MATCHER matcher) -> Match< decltype(begin(iterable))>
 
template<typename ITERABLE , typename MATCHER >
auto Split (const ITERABLE &iterable, MATCHER matcher) -> Result< BaseArray< ITERABLE >>
 
template<typename INDEXABLE , typename MATCHER >
auto SplitIndex (const INDEXABLE &indexable, IndexPair indexPair, MATCHER matcher) -> Result< BaseArray< Match< Int >>>
 
template<typename INDEXABLE , typename MATCHER >
auto SplitIndex (const INDEXABLE &indexable, MATCHER matcher) -> Result< void >
 
template<Int COUNT, typename ITERABLE , typename MATCHER >
auto SplitToTuple (const ITERABLE &iterable, MATCHER matcher) -> HomogenousTupleType< COUNT, ITERABLE >
 
template<Int COUNT, typename INDEXABLE , typename MATCHER >
auto SplitToTupleIndex (const INDEXABLE &indexable, IndexPair indexPair, MATCHER matcher) -> HomogenousTupleType< COUNT, Match< Int >>
 
template<Int COUNT, typename INDEXABLE , typename MATCHER >
auto SplitToTupleIndex (const INDEXABLE &indexable, MATCHER matcher) -> HomogenousTupleType< COUNT, Match< Int >>
 
template<typename ITERATE_FUNC , typename ITERABLE , typename MATCHER >
auto SplitIterate (ITERATE_FUNC iterFunc, const ITERABLE &iterable, MATCHER matcher) -> Result< Bool >
 
template<typename ITERATE_FUNC , typename INDEXABLE , typename MATCHER >
auto SplitIterateIndex (ITERATE_FUNC iterFunc, const INDEXABLE &indexable, IndexPair indexPair, MATCHER matcher) -> Result< Bool >
 
template<typename ITERATE_FUNC , typename INDEXABLE , typename MATCHER >
auto SplitIterateIndex (ITERATE_FUNC iterFunc, const INDEXABLE &indexable, const MATCHER &matcher) -> Result< Bool >
 
template<typename PRED >
auto ByPredicate (const PRED &pred) -> PredicateMatcher< std::reference_wrapper< const PRED >>
 
template<typename T >
auto ByValue (const T &value) -> PredicateMatcher< ValuePredicate< T >>
 
template<typename T , typename COMPARE >
auto ByValue (const T &value, const COMPARE &comp) -> PredicateMatcher< ValueComparePredicate< T, COMPARE >>
 
template<typename PRED >
auto ByRepeatingPredicate (const PRED &pred) -> RepeatingPredicateMatcher< PRED >
 
template<typename T >
auto ByRepeatingValue (const T &value) -> RepeatingPredicateMatcher< ValuePredicate< T >>
 
template<typename T , typename COMPARE >
auto ByRepeatingValue (const T &value, const COMPARE &comp) -> RepeatingPredicateMatcher< ValueComparePredicate< T, COMPARE >>
 
template<typename SEARCH_SEQ >
auto BySequence (const SEARCH_SEQ &searchSeq) -> SequenceMatcher< SEARCH_SEQ, maxon::details::EqualityCompare< typename std::iterator_traits< decltype(begin(searchSeq))>::value_type, typename std::iterator_traits< decltype(begin(searchSeq))>::value_type >>
 
template<typename SEARCH_SEQ , typename COMPARE >
auto BySequence (const SEARCH_SEQ &searchSeq, const COMPARE &comp) -> SequenceMatcher< SEARCH_SEQ, COMPARE >
 
template<typename ITERABLE1 , typename ITERABLE2 >
auto SetDifference (const ITERABLE1 &firstSet, const ITERABLE2 &secondSet) -> Result< ITERABLE1 >
 
template<typename ITERABLE1 , typename ITERABLE2 , typename APPENDABLE >
auto SetDifference (const ITERABLE1 &firstSet, const ITERABLE2 &secondSet, APPENDABLE &outContainer) -> Result< void >
 
template<typename ITERABLE , typename FINDABLE >
auto UnorderedSetDifference (const ITERABLE &firstSet, const FINDABLE &secondSet) -> Result< ITERABLE >
 
template<typename ITERABLE , typename FINDABLE , typename APPENDABLE >
auto UnorderedSetDifference (const ITERABLE &firstSet, const FINDABLE &secondSet, APPENDABLE &outputContainer) -> Result< void >
 
template<typename ERASABLE , typename ITERABLE >
auto ExcludeSetFromSet (ERASABLE &firstSet, const ITERABLE &secondSet) -> Result< void >
 
template<typename ITERATOR , typename SENTINEL , typename T >
auto Fill (ITERATOR first, SENTINEL sentinel, const T &value) -> ITERATOR
 
template<typename ITERATOR >
auto Reverse (ITERATOR first, ITERATOR last) -> ITERATOR
 
template<typename ITERATOR , typename SENTINEL >
auto Reverse (ITERATOR first, SENTINEL sentinel) -> ITERATOR
 
template<typename ITERATOR , typename SENTINEL , typename PREDICATE >
auto RemoveIf (ITERATOR first, SENTINEL sentinel, PREDICATE pred) -> ITERATOR
 
MAXON_ATTRIBUTE_FORCE_INLINE tm ConvertLocalDateTimeToTM (const LocalDateTime &dateTime)
 
MAXON_ATTRIBUTE_FORCE_INLINE LocalDateTime ConvertTMToLocalDateTime (const tm &st)
 
MAXON_ATTRIBUTE_FORCE_INLINE time_t mktime_r (struct tm *tm)
 
MAXON_ATTRIBUTE_FORCE_INLINE time_t timegm_r (struct tm *tm)
 
 __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)
 
template<typename T , typename E >
E && MakeDependentExpr (E &&value)
 
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)
 
template<typename TO , typename FROM >
GenericCastReturnType< TO, FROM, false >::type GenericReinterpretCast (FROM &&value)
 
template<typename TO , typename FROM >
GenericCastReturnType< TO, FROM, true >::type GenericUpCast (FROM &&value)
 
template<typename T >
T NullValue ()
 
 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)
 
enum maxon::VALUEKIND UInt64 MAXON_ENUM_ORDERED_FLAGS (VALUEKIND, "net.maxon.datatype.enum.valuekind", EARLY)
 
enum maxon::COLLECTION_KIND MAXON_ENUM_LIST (COLLECTION_KIND)
 
template<typename T >
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 >
 __attribute__ ((always_inline)) ResultOk< T > NewCopy(T &&src)
 
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)
 
enum maxon::SUBSYSTEM MAXON_ENUM_LIST (SUBSYSTEM, "net.maxon.datatype.enum.subsystem")
 
enum maxon::APPLICATION_URLTYPE MAXON_ENUM_LIST (APPLICATION_URLTYPE, "net.maxon.datatype.enum.application_urltype")
 
enum maxon::APPLICATIONMODE MAXON_ENUM_LIST (APPLICATIONMODE, "net.maxon.datatype.enum.applicationmode")
 
enum maxon::APPLICATIONFEATURE MAXON_ENUM_FLAGS (APPLICATIONFEATURE)
 
template<GET_DATATYPE_POLICY POLICY, typename T >
Result< DataType > PrivateGetDataType (ArrayInterface< T > **, OverloadRank0)
 
template<typename ARRAY >
 MAXON_IMPLEMENTATION_SIMPLE_REGISTER (ArrayImpl< ARRAY >)
 
template<typename T >
const ArrayInterface< T > * ToArrayPtr (const ArrayInterface< T > &array)
 
template<typename T >
WritableArrayInterface< T > * ToWritableArrayPtr (WritableArrayInterface< T > &array)
 
 MAXON_DATATYPE (BackgroundEntryTuple, "net.maxon.datatyoe.backgroundentrytuple")
 
enum maxon::BASEARRAYFLAGS MAXON_ENUM_FLAGS (BASEARRAYFLAGS)
 
 MAXON_DATATYPE (BitSet, "net.maxon.datatype.bitset")
 
template<typename T >
T * PrivateInitCopy (void *ptr, const T &src)
 
Int Ctz32 (Int32 x)
 
Int Ctz64 (Int64 x)
 
Int Clz32 (Int32 x)
 
Int Clz64 (Int64 x)
 
template<typename T >
Int Clz (T x)
 
template<typename T >
Int Ctz (T x)
 
template<typename T , Int N>
Block< T > ToBlock (T(&array)[N])
 
template<typename T >
Block< typename maxon::details::BlockType< T >::type > ToBlock (T *ptr, Int size)
 
template<typename T >
Block< T > ToSingletonBlock (T &value)
 
template<typename T >
Block< const T > ToSingletonBlock (const T &value)
 
template<typename T >
StridedBlock< typename maxon::details::BlockType< T >::type > ToBlock (T *ptr, Int size, Int stride)
 
Block< const Char > CharToBlock (const Char *str)
 
Block< const UChar > CharToBlock (const UChar *str)
 
template<Int N>
Block< const Char > CharToBlock (const Char(&str)[N])
 
template<Int N>
Block< const UChar > CharToBlock (const UChar(&str)[N])
 
template<Int N>
Block< const Utf32Char > CharToBlock (const Utf32Char(&str)[N])
 
enum maxon::BLOCKARRAYFLAGS MAXON_ENUM_FLAGS (BLOCKARRAYFLAGS)
 
constexpr Bool ConstExprStringsAreEqual (const Char *str1, const Char *str2)
 
enum maxon::BURSTTRIE_SORT MAXON_ENUM_LIST (BURSTTRIE_SORT)
 
enum maxon::BYTEORDER MAXON_ENUM_LIST (BYTEORDER)
 
MAXON_ATTRIBUTE_FORCE_INLINE UInt16 SwapByteOrder (UInt16 data)
 
MAXON_ATTRIBUTE_FORCE_INLINE Int16 SwapByteOrder (Int16 data)
 
MAXON_ATTRIBUTE_FORCE_INLINE UInt32 SwapByteOrder (UInt32 data)
 
MAXON_ATTRIBUTE_FORCE_INLINE Int32 SwapByteOrder (Int32 data)
 
MAXON_ATTRIBUTE_FORCE_INLINE UInt64 SwapByteOrder (UInt64 data)
 
MAXON_ATTRIBUTE_FORCE_INLINE Int64 SwapByteOrder (Int64 data)
 
MAXON_ATTRIBUTE_FORCE_INLINE UInt16 SwapUInt16 (UInt16 data)
 
MAXON_ATTRIBUTE_FORCE_INLINE Int16 SwapInt16 (Int16 data)
 
MAXON_ATTRIBUTE_FORCE_INLINE UInt32 SwapUInt32 (UInt32 data)
 
MAXON_ATTRIBUTE_FORCE_INLINE Int32 SwapInt32 (Int32 data)
 
MAXON_ATTRIBUTE_FORCE_INLINE UInt64 SwapUInt64 (UInt64 data)
 
MAXON_ATTRIBUTE_FORCE_INLINE Int64 SwapInt64 (Int64 data)
 
MAXON_ATTRIBUTE_FORCE_INLINE void SwapUInt16 (UInt16 *addr, Int count=1)
 
MAXON_ATTRIBUTE_FORCE_INLINE void SwapInt16 (Int16 *addr, Int count=1)
 
MAXON_ATTRIBUTE_FORCE_INLINE void SwapUInt32 (UInt32 *addr, Int count=1)
 
MAXON_ATTRIBUTE_FORCE_INLINE void SwapInt32 (Int32 *addr, Int count=1)
 
MAXON_ATTRIBUTE_FORCE_INLINE void SwapUInt64 (UInt64 *addr, Int count=1)
 
MAXON_ATTRIBUTE_FORCE_INLINE void SwapInt64 (Int64 *addr, Int count=1)
 
template<BYTEORDER order>
MAXON_ATTRIBUTE_FORCE_INLINE void ByteOrder_UInt16 (UInt16 *addr, Int count=1)
 
template<BYTEORDER order>
MAXON_ATTRIBUTE_FORCE_INLINE void ByteOrder_Int16 (Int16 *addr, Int count=1)
 
template<BYTEORDER order>
MAXON_ATTRIBUTE_FORCE_INLINE void ByteOrder_UInt32 (UInt32 *addr, Int count=1)
 
template<BYTEORDER order>
MAXON_ATTRIBUTE_FORCE_INLINE void ByteOrder_Int32 (Int32 *addr, Int count=1)
 
template<BYTEORDER order>
MAXON_ATTRIBUTE_FORCE_INLINE void ByteOrder_UInt64 (UInt64 *addr, Int count=1)
 
template<BYTEORDER order>
MAXON_ATTRIBUTE_FORCE_INLINE void ByteOrder_Int64 (Int64 *addr, Int count=1)
 
 MAXON_DATATYPE (BytesValue, "net.maxon.datatype.bytesvalue")
 
void ScanParameter (BytesValue &res, const Block< const Utf32Char > &str, Int &processed, const String &formatStatement, Bool &error)
 
template<typename C >
Int PrivateGetCount (const C &collection, OverloadRank0)
 
template<typename T , Int N>
Int PrivateGetCount (T(&array)[N], OverloadRank1)
 
template<typename C >
SFINAEHelper< Int, typename C::IsCollection >::type PrivateGetCount (const C &collection, OverloadRank2)
 
template<typename ITERABLE >
Int GetCount (const ITERABLE &iterable)
 
template<typename SET , typename KEY >
MAXON_ATTRIBUTE_FORCE_INLINE Bool PrivateContains (const SET &set, const KEY &key, OverloadRank0)
 
template<typename T , Int N, typename KEY >
Bool PrivateContains (T(&array)[N], const KEY &key, OverloadRank1)
 
template<typename SET , typename KEY >
MAXON_ATTRIBUTE_FORCE_INLINE auto PrivateContains (const SET &set, const KEY &key, OverloadRank1) -> decltype(set.Contains(key))
 
template<typename SET , typename KEY >
MAXON_ATTRIBUTE_FORCE_INLINE SFINAEHelper< Bool, typename SET::IsCollection >::type PrivateContains (const SET &set, const KEY &key, OverloadRank2)
 
template<typename PREDICATE , typename KEY >
MAXON_ATTRIBUTE_FORCE_INLINE Bool Contains (const PREDICATE &predicate, const KEY &key)
 
template<typename COMPARE , typename T1 , typename T2 >
MAXON_ATTRIBUTE_FORCE_INLINE Bool PrivateIsEqual (COMPARE &&cmp, const T1 &a, const T2 &b, OverloadRank0)
 
template<typename COMPARE , typename T1 , typename T2 >
MAXON_ATTRIBUTE_FORCE_INLINE auto PrivateIsEqual (COMPARE &&cmp, const T1 &a, const T2 &b, OverloadRank1) -> decltype(cmp.IsEqual(a, b))
 
template<typename PREDICATE , typename T1 , typename T2 >
MAXON_ATTRIBUTE_FORCE_INLINE Bool IsEqual (PREDICATE &&predicate, const T1 &a, const T2 &b)
 
 MAXON_MEMBERTYPE_DETECTOR (IsCollection, IsCollection, std::false_type)
 
enum maxon::COLLECTION_RESIZE_FLAGS MAXON_ENUM_FLAGS (COLLECTION_RESIZE_FLAGS, "net.maxon.datatype.enum.collection_resize_flags", EARLY)
 
template<typename COLLECTION , typename T >
std::conditional<!STD_IS_REPLACEMENT(reference, COLLECTION) &&(GetCollectionKind< COLLECTION >::value !=COLLECTION_KIND::NONE), T &&, T & >::type ValueForward (T &x)
 
template<typename COLLECTION , typename T , Bool STRIDED>
const Block< T, STRIDED, !STD_IS_REPLACEMENT(reference, COLLECTION) &&(GetCollectionKind< COLLECTION >::value !=COLLECTION_KIND::NONE)> & BlockForward (const Block< T, STRIDED > &block)
 
template<typename COLLECTION >
COLLECTION && PrivateGetMap (COLLECTION &&c, OverloadRank0)
 
template<typename COLLECTION >
Substitute< COLLECTION &&, typename std::remove_reference< COLLECTION >::type::MapType >::type PrivateGetMap (COLLECTION &&c, OverloadRank1)
 
enum maxon::CONFIGURATION_CATEGORY MAXON_ENUM_LIST (CONFIGURATION_CATEGORY)
 
enum maxon::CONFIGURATIONENTRY_ORIGIN MAXON_ENUM_LIST (CONFIGURATIONENTRY_ORIGIN)
 
enum maxon::CONFIGURATIONENTRY_STATE MAXON_ENUM_LIST (CONFIGURATIONENTRY_STATE)
 
 MAXON_DATATYPE (ConfigInit, "net.maxon.datatype.configinit")
 
 MAXON_DEPENDENCY (configuration)
 
Bool QueryConfigBool (const String &symbol)
 
template<GET_DATATYPE_POLICY POLICY, typename... T>
ResultOk< const ContainerDataType< T... > & > PrivateGetDataType (ContainerInterface< T... > **, OverloadRank1)
 
template<GET_DATATYPE_POLICY POLICY, Int DEPTH>
Result< DataType > PrivateGetDataType (RecursiveContainer< DEPTH > **, OverloadRank0)
 
 MAXON_DEPENDENCY (cpuidinit)
 
template<typename T1 , typename T2 >
MAXON_ATTRIBUTE_FORCE_INLINE bool operator== (const CustomSTLAllocator< T1 > &, const CustomSTLAllocator< T2 > &) noexcept
 
template<typename T1 , typename T2 >
MAXON_ATTRIBUTE_FORCE_INLINE bool operator!= (const CustomSTLAllocator< T1 > &, const CustomSTLAllocator< T2 > &) noexcept
 
 MAXON_REGISTRY (DataType, LegacyDataTypeIdentifiers, "net.maxon.registry.datatype.legacyidentifiers")
 
 MAXON_DATATYPE (LanguageStringDataDescription, "net.maxon.datatype.languagestringdatadescription")
 
 MAXON_DATATYPE (VariadicIdsElement, "net.maxon.datatype.variadicidselement")
 
template<typename T >
Result< void > AddResourceDefault (DataDictionary &props, const T &t, OverloadRank0)
 
template<typename T >
SFINAEHelper< Result< void >, typename T::HasDefault >::type AddResourceDefault (DataDictionary &props, const T &t, OverloadRank1)
 
template<typename TYPE >
Result< BaseArray< Tuple< Id, Data > > > BlockToEnumArray (const Block< TYPE > &enumBlock)
 
template<typename T >
Result< void > AddResourceProperty (DataDescription &description, const T &t, const Delegate< Result< void >(DataDictionary &props)> &addProps=nullptr)
 
template<typename T >
Result< void > EraseResourceProperty (DataDescription &description, const T &t)
 
enum maxon::CONDITIONTOKENTYPE MAXON_ENUM_LIST (CONDITIONTOKENTYPE)
 
 MAXON_DATATYPE (ProcessEnumListDelegate, "net.maxon.datatype.processenumlistdelegate")
 
 MAXON_REGISTRY (ProcessEnumListDelegate, ProcessEnumListDelegates, "net.maxon.datadescription.registry.processenumlist")
 
 MAXON_DATATYPE (EnumVariableResolveDelegate, "net.maxon.datatype.delegate.enumvariableresolve")
 
 MAXON_REGISTRY (EnumVariableResolveDelegate, EnumVariableResolveDelegates, "net.maxon.datadescription.registry.enumvariableresolve")
 
Bool UseFilterData (const Data *filterData, const Data &compare)
 
enum maxon::GETDATAFLAGS MAXON_ENUM_FLAGS (GETDATAFLAGS)
 
 MAXON_DECLARATION (Class< DataDescriptionDefinition >, DataDescriptionDefinitionClass, "net.maxon.class.datadescriptiondefinition")
 
 MAXON_DATATYPE (LanguageStringDataDescriptionDefinition, "net.maxon.datatype.languagestringdatadescriptiondefinition")
 
enum maxon::DBVERSION MAXON_ENUM_ORDERED_LIST (DBVERSION)
 
enum maxon::DESCRIPTIONMESSAGECHECKFLAGS MAXON_ENUM_FLAGS (DESCRIPTIONMESSAGECHECKFLAGS)
 
 MAXON_DATATYPE (DescriptionMessageCall, "net.maxon.datatype.descriptionmessagecall")
 
enum maxon::LOADDESCRIPTIONMODE MAXON_ENUM_LIST (LOADDESCRIPTIONMODE)
 
 MAXON_DECLARATION (Class< DataDescriptionObjectRef >, DataDescriptionObjectClass, "net.maxon.class.datadescriptionobject")
 
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)
 
 MAXON_REGISTRY (DataFormatReaderFactory, DataFormatReaderFactories, "net.maxon.registry.dataformatreaderfactories")
 
 MAXON_REGISTRY (DataFormatWriterFactory, DataFormatWriterFactories, "net.maxon.registry.dataformatwriterfactories")
 
 MAXON_DECLARATION (Class< DataFormatWriterRef >, DataFormatWriterBinaryClass, "net.maxon.class.dataformatwriterbinary")
 
 MAXON_DECLARATION (Class< DataFormatWriterRef >, DataFormatWriterJsonClass, "net.maxon.class.dataformatwriterjson")
 
 MAXON_DECLARATION (Class< DataFormatWriterRef >, DataFormatWriterXmlClass, "net.maxon.class.dataformatwriterxml")
 
 MAXON_DECLARATION (Class< DataFormatReaderRef >, DataFormatReaderBinaryClass, "net.maxon.class.dataformatreaderbinary")
 
 MAXON_DECLARATION (Class< DataFormatReaderRef >, DataFormatReaderJsonClass, "net.maxon.class.dataformatreaderjson")
 
 MAXON_DECLARATION (Class< DataFormatReaderRef >, DataFormatReaderXmlClass, "net.maxon.class.dataformatreaderxml")
 
 MAXON_DATATYPE (IDENT_VOID, "net.maxon.ident_void")
 
template<typename T >
ResultPtr< void > CreateHelper ()
 
template<typename T >
void DeleteHelper (void *helper)
 
template<typename MAINCLASS , typename HELPERCLASS >
Result< void > ReadHelper (DataSerializeInterface *ds, void *classPtr, void *helperPtr, UInt elementHash)
 
template<typename MAINCLASS , typename HELPERCLASS >
Result< void > WriteHelper (DataSerializeInterface *ds, void *classPtr, void *helperPtr, UInt elementHash)
 
template<typename T >
void ArrayConversionHelper (void *arrayPtr, Char *memBuffer)
 
template<typename T >
void SetConversionHelper (void *mapPtr, Char *memBuffer)
 
template<typename T >
void MapConversionHelper (void *mapPtr, Char *memBuffer)
 
DESCRIBEFLAGS operator| (DESCRIBEFLAGS a, DESCRIBEFLAGS b)
 
DESCRIBEFLAGS operator& (DESCRIBEFLAGS a, DESCRIBEFLAGS b)
 
DESCRIBEFLAGS operator~ (DESCRIBEFLAGS a)
 
DESCRIBEFLAGS & operator&= (DESCRIBEFLAGS &a, DESCRIBEFLAGS b)
 
enum maxon::PREPAREHELPERFLAGS MAXON_ENUM_FLAGS (PREPAREHELPERFLAGS)
 
 MAXON_DECLARATION (Class< DataSerializeRef >, DataSerializeBaseClass, "net.maxon.class.dataserializebase")
 
 MAXON_DECLARATION (Class< DataSerializeReaderRef >, DataSerializeReaderClass, "net.maxon.class.dataserializereader")
 
 MAXON_DECLARATION (Class< DataSerializeWriterRef >, DataSerializeWriterClass, "net.maxon.class.dataserializewriter")
 
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, typename T >
std::enable_if< STD_IS_REPLACEMENT(enum, T), ResultOk< const DataType & > >::type PrivateGetDataType (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 >
std::enable_if< GetDirectlyReferencedType< T >::value, Result< DataType > >::type PrivateGetDataType (T **, 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 >
SFINAEHelper< Result< DataType >, typename T::VectorStrideType >::type PrivateGetDataType (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)
 
 MAXON_DATATYPE_EARLY_ENUM (WRITEMETA, "net.maxon.datatype.enum.writemeta")
 
 MAXON_DATATYPE_EARLY_ENUM (TARGETAUDIENCE, "net.maxon.datatype.enum.targetaudience")
 
 MAXON_DATATYPE_EARLY_ENUM (OUTPUT, "net.maxon.datatype.enum.output")
 
 MAXON_DATATYPE_EARLY_ENUM (VALUEKIND, "net.maxon.datatype.enum.valuekind")
 
 MAXON_DATATYPE_EARLY_ENUM (COMPARERESULT, "net.maxon.datatype.enum.compareresult")
 
 MAXON_DATATYPE_EARLY_ENUM (EQUALITY, "net.maxon.datatype.enum.equality")
 
 MAXON_DATATYPE_EARLY_ENUM (COLLECTION_RESIZE_FLAGS, "net.maxon.datatype.enum.collection_resize_flags")
 
enum maxon::DATATYPEBUILDERNAME MAXON_ENUM_LIST (DATATYPEBUILDERNAME)
 
 MAXON_DATATYPE (DataTypeBuilderEntry, "net.maxon.datatype.datatypebuilderentry")
 
 MAXON_REGISTRY (DataTypeBuilderEntry, DataTypeBuilderRegistry, "net.maxon.registry.datatypebuilderregistry")
 
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::DAYOFWEEK MAXON_ENUM_LIST (DAYOFWEEK)
 
enum maxon::DST Int16 MAXON_ENUM_LIST (DST)
 
enum maxon::JULIANDATE MAXON_ENUM_LIST (JULIANDATE)
 
 MAXON_DATATYPE (UniversalDateTime, "net.maxon.datatype.universaldatetime")
 
 MAXON_DATATYPE (LocalDateTime, "net.maxon.datatype.localdatetime")
 
void ScanParameter (UniversalDateTime &res, const Block< const Utf32Char > &str, Int &processed, const String &formatStatement, Bool &error)
 
enum maxon::HARDWAREBREAKPOINTTYPE MAXON_ENUM_LIST (HARDWAREBREAKPOINTTYPE)
 
enum maxon::HARDWAREBREAKPOINTSIZE MAXON_ENUM_LIST (HARDWAREBREAKPOINTSIZE)
 
Int sprintf_safe (Char *_DstBuf, Int _MaxCount, const Char *_Format,...)
 
 MAXON_DECLARATION (ComponentDescriptor, EagerDecoratorComponent, "net.maxon.component.eagerdecorator")
 
 MAXON_DECLARATION (ComponentDescriptor, WeakDecoratorComponent, "net.maxon.component.weakdecorator")
 
template<typename T >
MAXON_ATTRIBUTE_FORCE_INLINE ResultPtr< T > _ReallocMem (T *p, Int cnt, MAXON_SOURCE_LOCATION_DECLARATION)
 
template<typename T >
void DeleteMem (T *&p)
 
void DeleteConstPtrMem (const void *p)
 
MAXON_ATTRIBUTE_FORCE_INLINE void MemCopy (void *dst, const void *src, Int size)
 
MAXON_ATTRIBUTE_FORCE_INLINE void MemMove (void *dst, const void *src, Int size)
 
template<typename T >
MAXON_ATTRIBUTE_FORCE_INLINE void MemCopyType (T *dst, const T *src, Int cnt)
 
template<typename T >
MAXON_ATTRIBUTE_FORCE_INLINE void MemMoveType (T *dst, const T *src, Int cnt)
 
MAXON_ATTRIBUTE_FORCE_INLINE void ClearMem (void *mem, Int size, UChar value=0)
 
MAXON_ATTRIBUTE_FORCE_INLINE void SecureClearMem (volatile void *mem, Int size, UChar value=0)
 
MAXON_ATTRIBUTE_FORCE_INLINE Int CompareMem (const void *block1, const void *block2, Int size)
 
template<typename T >
MAXON_ATTRIBUTE_FORCE_INLINE void ClearMemType (T *data_ptr, Int cnt, UChar value=0)
 
void operator% (const Result< Bool > &res, Result< Bool > &yieldResult)
 
void operator% (const Result< void > &res, Result< Bool > &yieldResult)
 
 MAXON_REGISTRY (DescriptionProcessor, DescriptionProcessors, "net.maxon.registry.descriptionprocessors")
 
 MAXON_DECLARATION (Class< Error >, ErrorObjectClass, "net.maxon.class.errorobject")
 
 MAXON_DECLARATION (AggregatedError, AggregatedErrorObject, "net.maxon.object.aggregatederror")
 
MAXON_ATTRIBUTE_FORCE_INLINE void operator% (ErrorPtr &rv, ThreadReferencedError &err)
 
template<typename R >
R Cast (ErrorPtr &ref)
 
template<typename ERRORTYPE >
Bool IsErrorOfType (const Error &err)
 
 MAXON_REGISTRY (JobRef, ExecutionJobs, "net.maxon.registry.executionjobs")
 
 MAXON_MEMBERTYPE_DETECTOR (IsFidClass, FidType, std::false_type)
 
template<typename RESTRICT , Bool ONLYFID, typename KEY >
std::enable_if<!IsFidClass< KEY >::value, typename std::conditional< STD_IS_REPLACEMENT(reference, KEY)||STD_IS_REPLACEMENT(const, KEY), ConstDataPtr, MoveDataPtr >::type >::type ConvertKeyToDataPtr (KEY &&key)
 
template<typename RESTRICT , Bool ONLYFID, typename KEY >
std::enable_if< IsFidClass< KEY >::value, ConstDataPtr >::type ConvertKeyToDataPtr (KEY &&key)
 
template<typename T >
RESTRICT TestRestriction (T y, OverloadRank0)
 
 MAXON_MEMBERTYPE_DETECTOR (GetRestrict, RESTRICT_DICTIONARY_PROPS, maxon::RESTRICT)
 
Bool IsSourceControlAvailable ()
 
enum maxon::FILEFORMATDETECTIONFLAGS MAXON_ENUM_FLAGS (FILEFORMATDETECTIONFLAGS)
 
 MAXON_REGISTRY (FileFormat, FileFormats, "net.maxon.registry.fileformats")
 
 MAXON_DECLARATION (Class< FileFormat >, FileFormatBaseClass, "net.maxon.class.fileformatbase")
 
 MAXON_DECLARATION (Class< FileFormatDetectionCacheRef >, FileFormatDetectionCacheClass, "net.maxon.class.fileformatdetectioncache")
 
enum maxon::FILEFORMAT_PRIORITY MAXON_ENUM_LIST (FILEFORMAT_PRIORITY)
 
FILEFORMAT_PRIORITY operator+ (FILEFORMAT_PRIORITY s1, FILEFORMAT_PRIORITY s2)
 
FILEFORMAT_PRIORITY operator- (FILEFORMAT_PRIORITY s1, FILEFORMAT_PRIORITY s2)
 
 MAXON_REGISTRY (FileFormatHandler, FileFormatHandlers, "net.maxon.registry.fileformathandlers")
 
 MAXON_MEMBERTYPE_DETECTOR (GetNonConstIteratorType, Iterator, std::false_type)
 
 MAXON_MEMBERTYPE_DETECTOR (GetConstIteratorType, ConstIterator, std::false_type)
 
 MAXON_MEMBERTYPE_DETECTOR (GetCollectionType, CollectionType, T)
 
 MAXON_MEMBERTYPE_DETECTOR (IsForEachIterator, IsForEachIterator, std::false_type)
 
template<typename I >
ReverseIterator< typename GetIteratorType< typename std::remove_reference< I >::type >::type > RBegin (I &&iterable)
 
template<typename I >
ReverseIterator< typename GetIteratorType< typename std::remove_reference< I >::type >::type > REnd (I &&iterable)
 
template<typename COLLECTION >
MAXON_ATTRIBUTE_FORCE_INLINE auto begin (COLLECTION &&c) -> decltype(c.Begin())
 
template<typename COLLECTION >
MAXON_ATTRIBUTE_FORCE_INLINE auto end (COLLECTION &&c) -> decltype(c.End())
 
template<GET_DATATYPE_POLICY POLICY, typename T >
Result< DataType > PrivateGetDataType (ForwardRef< T > **, OverloadRank0)
 
Bool CompareFloat (Float32 a, Float32 b, Float32 epsilon=1e-10f)
 
Bool CompareFloat (Float64 a, Float64 b, Float64 epsilon=1e-10)
 
Bool CompareFloatTolerant (Float32 a, Float32 b)
 
Bool CompareFloatTolerant (Float64 a, Float64 b)
 
Bool CheckFloat (Float32 r)
 
Bool CheckFloat (Float64 r)
 
Float32 RepairFloat (Float32 r)
 
Float64 RepairFloat (Float64 r)
 
Float32 BoxStep (Float32 lowerLimit, Float32 upperLimit, Float32 x)
 
Float64 BoxStep (Float64 lowerLimit, Float64 upperLimit, Float64 x)
 
Float32 SmoothStep (Float32 lowerLimit, Float32 upperLimit, Float32 x)
 
Float64 SmoothStep (Float64 lowerLimit, Float64 upperLimit, Float64 x)
 
Float32 Modulo (Float32 a, Float32 b)
 
Float64 Modulo (Float64 a, Float64 b)
 
Int32 Modulo (Int32 a, Int32 b)
 
Int64 Modulo (Int64 a, Int64 b)
 
Float32 Bias (Float32 b, Float32 x)
 
Float64 Bias (Float64 b, Float64 x)
 
Float32 Truncate (Float32 x)
 
Float64 Truncate (Float64 x)
 
enum maxon::HASHMAP_ENTRY_LAYOUT MAXON_ENUM_LIST (HASHMAP_ENTRY_LAYOUT)
 
enum maxon::HASHMAP_MODE MAXON_ENUM_LIST (HASHMAP_MODE)
 
 MAXON_DECLARATION (Class< HierarchyObjectRef<>>, HierarchyObjectClass, "net.maxon.class.hierarchyobject")
 
template<typename REFTYPE >
static Result< Bool > TraverseChildren (const REFTYPE &object, const Delegate< Result< Bool >(const REFTYPE &object, const REFTYPE &parent, const ConstDataPtr &branchId, Int depth)> &function, const ConstDataPtr &branchId=ConstDataPtr(), Int depth=Int(0))
 
template<typename REFTYPE >
static Result< Bool > TraverseMeAndChildren (const REFTYPE &object, const Delegate< Result< Bool >(const REFTYPE &object, const REFTYPE &parent, const ConstDataPtr &branchId, Int depth)> &function, const ConstDataPtr &branchId=ConstDataPtr(), Int depth=Int(0))
 
template<typename REFTYPE >
static Result< Bool > TraverseChildren (const REFTYPE &t, const ConstDataPtr &branch, const Delegate< Result< Bool >(const REFTYPE &child, const REFTYPE &parent, const ConstDataPtr &branch, Int depth)> &func, Int depth)
 
template<typename REFTYPE >
static Result< Bool > TraverseMeAndChildren (const REFTYPE &t, const REFTYPE &parent, const ConstDataPtr &branch, const Delegate< Result< Bool >(const REFTYPE &child, const REFTYPE &parent, const ConstDataPtr &branch, Int depth)> &func, Int depth=0)
 
enum maxon::ASSET_UPDATE_POLICY MAXON_ENUM_LIST (ASSET_UPDATE_POLICY, "net.maxon.datatype.enum.asset_update_policy")
 
Bool LessThan (UInt a1, UInt a2, UInt b1, UInt b2)
 
template<typename C >
NullValueDetector< C *, &C::NullValue >::type ImplementationCreateNullValue (OverloadRank3)
 
template<typename C >
std::enable_if< MAXON_IS_COW_KIND(C::PrivateInterface::Hxx1::ReferenceClass::Handler::KIND), C * >::type ImplementationCreateNullValue (OverloadRank2)
 
template<typename C >
SFINAEHelper< C *, typename C::PrivateInterface::Hxx1::ReferenceClass::Handler >::type ImplementationCreateNullValue (OverloadRank1)
 
template<typename C >
C * ImplementationCreateNullValue (OverloadRank0)
 
template<typename C >
NullValueDetector< C *, &C::NullValue >::type ImplementationDestroyNullValue (const C *, OverloadRank3)
 
template<typename C >
std::enable_if< MAXON_IS_COW_KIND(C::PrivateInterface::Hxx1::ReferenceClass::Handler::KIND), C * >::type ImplementationDestroyNullValue (const C *o, OverloadRank2)
 
template<typename C >
void ImplementationDestroyNullValue (const C *, OverloadRank0)
 
enum maxon::IOARCHIVESTOREMETHOD MAXON_ENUM_LIST (IOARCHIVESTOREMETHOD)
 
enum maxon::IOARCHIVEEXTRACTFLAGS MAXON_ENUM_FLAGS (IOARCHIVEEXTRACTFLAGS)
 
 MAXON_REGISTRY (Class< ReadArchiveRef >, ReadArchiveClasses, "net.maxon.registry.readarchiveclasses")
 
 MAXON_REGISTRY (Class< WriteArchiveRef >, WriteArchiveClasses, "net.maxon.registry.writearchiveclasses")
 
enum maxon::IOBROWSEFLAGS MAXON_ENUM_FLAGS (IOBROWSEFLAGS, "net.maxon.datatype.enum.iobrowseflags")
 
 MAXON_DECLARATION (Class< IoBrowseRef >, IoBrowseBaseClass, "net.maxon.class.iobrowsebase")
 
 MAXON_DECLARATION (Class< IoConnectionRef >, IoConnectionBaseClass, "net.maxon.class.ioconnectionbase")
 
 MAXON_DECLARATION (Class< IoConnectionRef >, IoConnectionFileClass, "net.maxon.class.ioconnectionfile")
 
enum maxon::IOTIMEMODE MAXON_ENUM_LIST (IOTIMEMODE, "net.maxon.datatype.enum.iotimemode")
 
enum maxon::URLCOMPARE MAXON_ENUM_LIST (URLCOMPARE, "net.maxon.datatype.enum.urlcompare")
 
enum maxon::IODETECT MAXON_ENUM_LIST (IODETECT, "net.maxon.datatype.enum.iodetect")
 
enum maxon::OPENSTREAMFLAGS MAXON_ENUM_FLAGS (OPENSTREAMFLAGS, "net.maxon.datatype.enum.openstreamflags")
 
enum maxon::NORMALIZEFLAGS MAXON_ENUM_FLAGS (NORMALIZEFLAGS, "net.maxon.datatype.enum.normalizeflags")
 
enum maxon::IOATTRIBUTES UInt MAXON_ENUM_FLAGS (IOATTRIBUTES, "net.maxon.datatype.enum.ioattributes")
 
void ConvertIoAttributes (IOATTRIBUTES &attributes)
 
enum maxon::IOSHOWINOSFLAGS MAXON_ENUM_FLAGS (IOSHOWINOSFLAGS, "net.maxon.datatype.enum.ioshowinosflags")
 
 MAXON_REGISTRY (IoHandler, IoHandlers, "net.maxon.registry.iohandlers")
 
 MAXON_DECLARATION (Class< IoHandler >, IoHandlerObjectBaseClass, "net.maxon.class.iohandlerobjectbase")
 
 MAXON_DECLARATION (Class< IoHandler >, IoHandlerObjectFileClass, "net.maxon.class.iohandlerobjectfile")
 
Result< Url > CreateMemoryFileWithSuffix (const String &suffix=String())
 
 MAXON_DECLARATION (Class< IoDualInOutputStreamRef >, InOutputStreamDualClass, "net.maxon.class.inoutputstreamdual")
 
 MAXON_DECLARATION (Class< IoError >, IoErrorObjectClass, "net.maxon.class.ioerrorobject")
 
 MAXON_DECLARATION (Class< InputStreamRef >, InputStreamBaseClass, "net.maxon.class.inputstreambase")
 
 MAXON_DECLARATION (Class< OutputStreamRef >, OutputStreamBaseClass, "net.maxon.class.outputstreambase")
 
 MAXON_DECLARATION (Class< InOutputStreamRef >, InOutputStreamBaseClass, "net.maxon.class.inoutputstreambase")
 
 MAXON_DECLARATION (Class< InputStreamRef >, InputStreamDecoratorBaseClass, "net.maxon.class.inputstreamdecorator")
 
 MAXON_DECLARATION (Class< OutputStreamRef >, OutputStreamDecoratorBaseClass, "net.maxon.class.outputstreamdecorator")
 
 MAXON_DECLARATION (Class< InOutputStreamRef >, InOutputStreamDecoratorBaseClass, "net.maxon.class.inoutputstreamdecorator")
 
Result< Int > Int64ToInt (Int64 value)
 
template<typename FN >
auto ExecuteOnMainThread (FN &&fn, WAITMODE waitMode=WAITMODE::DEFAULT, TimeValue wait=TIMEVALUE_INFINITE) -> decltype(fn())
 
 MAXON_DATATYPE (JobRef, "net.maxon.datatype.job")
 
enum maxon::JOBGROUPFLAGS MAXON_ENUM_FLAGS (JOBGROUPFLAGS)
 
enum maxon::STATICJOBGROUPFLAGS MAXON_ENUM_FLAGS (STATICJOBGROUPFLAGS)
 
enum maxon::STATICJOBARRAYFLAGS MAXON_ENUM_FLAGS (STATICJOBARRAYFLAGS)
 
enum maxon::JOBQUEUETYPE MAXON_ENUM_LIST (JOBQUEUETYPE)
 
enum maxon::JOBQUEUEMODE MAXON_ENUM_LIST (JOBQUEUEMODE)
 
enum maxon::LEXERSYMBOL UChar MAXON_ENUM_LIST (LEXERSYMBOL)
 
enum maxon::LEXERSYMBOLFLAGS MAXON_ENUM_FLAGS (LEXERSYMBOLFLAGS)
 
enum maxon::LEXERINITFLAGS MAXON_ENUM_FLAGS (LEXERINITFLAGS)
 
template<typename FLOAT >
SqrMat3< Vec3< FLOAT > > VectorToSquareMatrix (const Vec3< FLOAT > &dirVector, const Vec3< FLOAT > &upVector)
 
template<typename FLOAT >
SqrMat3< Vec3< FLOAT > > CheckedVectorToSquareMatrix (const Vec3< FLOAT > &dirVector, const Vec3< FLOAT > &upVector)
 
template<typename FLOAT >
Mat3< Vec3< FLOAT > > VectorToMatrix (const Vec3< FLOAT > &dirVector, const Vec3< FLOAT > &upVector)
 
template<typename FLOAT >
Mat3< Vec3< FLOAT > > GetTranslationMatrix (const Vec3< FLOAT > &translation)
 
template<typename FLOAT >
SqrMat3< Vec3< FLOAT > > GetScaleMatrix (const Vec3< FLOAT > &scale)
 
template<typename FLOAT >
SqrMat3< Vec3< FLOAT > > GetRotationMatrixX (FLOAT angle)
 
template<typename FLOAT >
SqrMat3< Vec3< FLOAT > > GetRotationMatrixY (FLOAT angle)
 
template<typename FLOAT >
SqrMat3< Vec3< FLOAT > > GetRotationMatrixZ (FLOAT angle)
 
template<typename FLOAT >
Mat2< Vec2< FLOAT > > GetTranslationMatrix (const Vec2< FLOAT > &translation)
 
template<typename FLOAT >
SqrMat2< Vec2< FLOAT > > GetScaleMatrix (const Vec2< FLOAT > &scale)
 
template<typename FLOAT >
SqrMat2< Vec2< FLOAT > > GetRotationMatrix (FLOAT angle)
 
enum maxon::ROTATIONORDER MAXON_ENUM_LIST (ROTATIONORDER)
 
template<typename FLOAT >
Vec3< FLOAT > GetRotationAngles (const SqrMat3< Vec3< FLOAT >> &m, ROTATIONORDER rotationOrder)
 
template<typename FLOAT >
Vec3< FLOAT > GetRotationAngles (const Vec3< FLOAT > &direction, ROTATIONORDER rotationOrder)
 
template<typename FLOAT >
SqrMat3< Vec3< FLOAT > > GetRotationMatrix (const Vec3< FLOAT > &rotation, ROTATIONORDER rotationOrder)
 
template<typename FLOAT >
Mat3< Vec3< FLOAT > > GetPSRMatrix (const Vec3< FLOAT > &position, const Vec3< FLOAT > &scale, const Vec3< FLOAT > &rotation, ROTATIONORDER rotationOrder)
 
template<typename FLOAT >
Vec3< FLOAT > GetOptimumRotation (const Vec3< FLOAT > &oldRotation, const Vec3< FLOAT > &newRotation, ROTATIONORDER rotationOrder)
 
template<typename FLOAT >
Vec3< FLOAT > GetClosestPointOnLine (const Vec3< FLOAT > &lineOrigin, const Vec3< FLOAT > &lineDirection, const Vec3< FLOAT > &point)
 
template<typename FLOAT >
FLOAT GetPointLineDistance (const Vec3< FLOAT > &lineOrigin, const Vec3< FLOAT > &lineDirection, const Vec3< FLOAT > &point)
 
template<typename FLOAT >
Vec3< FLOAT > ReflectRay (const Vec3< FLOAT > &direction, const Vec3< FLOAT > &normal)
 
template<typename FLOAT >
Vec3< FLOAT > RGBToHSV (const Col3< FLOAT > &color)
 
template<typename FLOAT >
Col3< FLOAT > HSVToRGB (const Vec3< FLOAT > &color)
 
template<typename FLOAT >
Vec3< FLOAT > RGBToHSL (const Col3< FLOAT > &color)
 
template<typename FLOAT >
Col3< FLOAT > HSLToRGB (const Vec3< FLOAT > &color)
 
template<typename FLOAT >
void GetRotationAxis (const SqrMat3< Vec3< FLOAT >> &m, Vec3< FLOAT > &axisVector, FLOAT &axisRotation)
 
template<typename FLOAT >
SqrMat3< Vec3< FLOAT > > GetRotationMatrixFromAxis (const Vec3< FLOAT > &axisVector, FLOAT axisRotation)
 
template<typename MATRIXTYPE >
Bool IsMatrixRectangular (const MATRIXTYPE &m, typename MATRIXTYPE::ValueType epsilon=1e-10_f)
 
template<typename ITERABLETYPE >
MAXON_ATTRIBUTE_FORCE_INLINE std::remove_reference< ITERABLETYPE >::type::ValueType GetSum (ITERABLETYPE &&array)
 
template<typename ITERABLETYPE >
MAXON_ATTRIBUTE_FORCE_INLINE std::remove_reference< ITERABLETYPE >::type::ValueType GetAverage (ITERABLETYPE &&array)
 
Result< void > PrivateConsoleOutput (const String &str, const SourceLocation &loc, WRITEMETA level)
 
 MAXON_DECLARATION (Class< LoggerTypeRef >, LoggerTypeBaseClass, "net.maxon.class.loggertypebase")
 
 MAXON_REGISTRY (Class< LoggerTypeRef >, LoggerTypes, "net.maxon.core.registry.loggertypes")
 
 MAXON_REGISTRY (LoggerRef, Loggers, "net.maxon.core.registry.loggers")
 
enum maxon::MACHINESTATE MAXON_ENUM_FLAGS (MACHINESTATE)
 
 MAXON_DECLARATION (Class< MachineRef >, LocalMachineClass, "net.maxon.class.localmachine")
 
 MAXON_DATATYPE (CreateObjectRefFunc, "net.maxon.datatype.createobjectreffunc")
 
 MAXON_REGISTRY (CreateObjectRefFunc, MachineImplementationFactories, "net.maxon.registry.machineimplementationfactories")
 
template<typename MAP >
 MAXON_IMPLEMENTATION_SIMPLE_REGISTER (MapImpl< MAP >)
 
template<typename K , typename V >
const MapInterface< K, V > * ToMapPtr (const MapInterface< K, V > &map)
 
template<typename K , typename V >
WritableMapInterface< K, V > * ToWritableMapPtr (WritableMapInterface< K, V > &map)
 
template<typename T , Int STR, typename S >
Col3< typename MultiplicativePromotion< T, S, STD_IS_REPLACEMENT(scalar, S)>::type, 1 > operator* (S s, const Col3< T, STR > &v)
 
template<GET_DATATYPE_POLICY POLICY, typename T >
Result< DataType > PrivateGetDataType (Col3< T, 1 > **, OverloadRank1)
 
template<typename T , Int STR, typename S >
Col4< typename MultiplicativePromotion< T, S, STD_IS_REPLACEMENT(scalar, S)>::type, 1 > operator* (S s, const Col4< T, STR > &v)
 
template<GET_DATATYPE_POLICY POLICY, typename T >
Result< DataType > PrivateGetDataType (Col4< T, 1 > **, OverloadRank1)
 
template<typename T , Int STR, typename S >
Vec3< typename MultiplicativePromotion< T, S, STD_IS_REPLACEMENT(scalar, S)>::type, 1 > operator* (S s, const Vec3< T, STR > &v)
 
template<GET_DATATYPE_POLICY POLICY, typename T >
Result< DataType > PrivateGetDataType (Vec3< T, 1 > **, OverloadRank1)
 
template<typename T , Int STR, typename S , typename SPACE >
Vec2< typename MultiplicativePromotion< T, S, STD_IS_REPLACEMENT(scalar, S)>::type, 1, SPACE > operator* (S s, const Vec2< T, STR, SPACE > &v)
 
template<GET_DATATYPE_POLICY POLICY, typename T , typename SPACE >
Result< DataType > PrivateGetDataType (Vec2< T, 1, SPACE > **, OverloadRank1)
 
template<typename T , Int STR, typename S >
Vec4< typename MultiplicativePromotion< T, S, STD_IS_REPLACEMENT(scalar, S)>::type, 1 > operator* (S s, const Vec4< T, STR > &v)
 
template<GET_DATATYPE_POLICY POLICY, typename T >
Result< DataType > PrivateGetDataType (Vec4< T, 1 > **, OverloadRank1)
 
template<typename V , typename V2 >
Mat3< typename MultiplicativePromotion< V, typename V2::ValueType >::type > operator* (const SqrMat3< V > &m, const Mat3< V2 > &m2)
 
template<GET_DATATYPE_POLICY POLICY, typename T >
Result< DataType > PrivateGetDataType (SqrMat3< T > **, OverloadRank1)
 
template<GET_DATATYPE_POLICY POLICY, typename T >
Result< DataType > PrivateGetDataType (Mat3< T > **, OverloadRank1)
 
template<typename V , typename V2 >
Mat2< typename MultiplicativePromotion< V, typename V2::ValueType >::type > operator* (const SqrMat2< V > &m, const Mat2< V2 > &m2)
 
template<GET_DATATYPE_POLICY POLICY, typename T >
Result< DataType > PrivateGetDataType (SqrMat2< T > **, OverloadRank1)
 
template<GET_DATATYPE_POLICY POLICY, typename T >
Result< DataType > PrivateGetDataType (Mat2< T > **, OverloadRank1)
 
template<GET_DATATYPE_POLICY POLICY, typename T >
Result< DataType > PrivateGetDataType (SqrMat4< T > **, OverloadRank1)
 
 MAXON_REGISTRY (DataDictionary, ModuleVersionInfos, "net.maxon.registry.moduleversioninfos")
 
template<typename T >
MAXON_ATTRIBUTE_FORCE_INLINE const T & PrivateConstRefNullValue (T *, OverloadRank0)
 
template<typename T >
MAXON_ATTRIBUTE_FORCE_INLINE const T & PrivateConstRefNullValueHelper (OverloadRank0)
 
template<typename T >
MAXON_ATTRIBUTE_FORCE_INLINE NullValueDetector< const T &, &T::NullValue >::type PrivateConstRefNullValueHelper (OverloadRank1)
 
template<typename T >
MAXON_ATTRIBUTE_FORCE_INLINE NullValueDetector< const T &, &T::NullValueRef >::type PrivateConstRefNullValueHelper (OverloadRank2)
 
template<typename T >
MAXON_ATTRIBUTE_FORCE_INLINE T PrivateNullValueHelper (OverloadRank0)
 
template<typename T >
MAXON_ATTRIBUTE_FORCE_INLINE NullValueDetector< T, &T::NullValue >::type PrivateNullValueHelper (OverloadRank1)
 
template<typename T >
MAXON_ATTRIBUTE_FORCE_INLINE NullValueDetector< const T &, &T::NullValue >::type PrivateNullValueHelper (OverloadRank1)
 
template<typename T >
MAXON_ATTRIBUTE_FORCE_INLINE T PrivateNullValueDispatcher (OverloadRank0)
 
template<typename T >
MAXON_ATTRIBUTE_FORCE_INLINE SFINAEHelper< T, typename NullValueFunctions< typename std::decay< T >::type >::Default >::type PrivateNullValueDispatcher (OverloadRank1)
 
template<typename T >
MAXON_ATTRIBUTE_FORCE_INLINE std::enable_if< IsZeroInitialized< typename std::decay< T >::type >::value||STD_IS_REPLACEMENT(same, typename std::decay< T >::type, Generic), T >::type PrivateNullValueDispatcher (OverloadRank2)
 
template<typename T >
MAXON_ATTRIBUTE_FORCE_INLINE T NullValue ()
 
template<>
MAXON_ATTRIBUTE_FORCE_INLINE void NullValue< void > ()
 
enum maxon::NULL_RETURN_REASON MAXON_ENUM_LIST (NULL_RETURN_REASON)
 
ThreadReferencedError PrivateGetNullReturnError (NULL_RETURN_REASON reason)
 
MAXON_ATTRIBUTE_FORCE_INLINE void PrivateLogNullptrError ()
 
MAXON_ATTRIBUTE_FORCE_INLINE Bool PrivateLogNullptrError (Bool result)
 
template<typename T >
MAXON_ATTRIBUTE_FORCE_INLINE T PrivateNullReturnValue (NULL_RETURN_REASON reason, OverloadRank0)
 
template<typename T >
MAXON_ATTRIBUTE_FORCE_INLINE SFINAEHelper< T, typename NullValueFunctions< typename std::decay< T >::type >::Default >::type PrivateNullReturnValue (NULL_RETURN_REASON reason, OverloadRank1)
 
template<typename T >
MAXON_ATTRIBUTE_FORCE_INLINE SFINAEHelper< T, typename NullValueFunctions< typename std::decay< T >::type >::ResultMarker >::type PrivateNullReturnValue (NULL_RETURN_REASON reason, OverloadRank2)
 
template<typename T >
MAXON_ATTRIBUTE_FORCE_INLINE std::enable_if< STD_IS_REPLACEMENT(same, Id, typename std::decay< T >::type), T >::type PrivateNullReturnValue (NULL_RETURN_REASON reason, OverloadRank3)
 
template<typename T >
MAXON_ATTRIBUTE_FORCE_INLINE std::enable_if< IsZeroInitialized< typename std::decay< T >::type >::value||STD_IS_REPLACEMENT(same, typename std::decay< T >::type, Generic), T >::type PrivateNullReturnValue (NULL_RETURN_REASON reason, OverloadRank4)
 
template<typename T >
MAXON_ATTRIBUTE_FORCE_INLINE T PrivateIncompleteNullReturnValue (NULL_RETURN_REASON reason, OverloadRank0)
 
template<typename T >
MAXON_ATTRIBUTE_FORCE_INLINE SFINAEHelper< T, typename NullValueFunctions< typename std::decay< T >::type >::Default >::type PrivateIncompleteNullReturnValue (NULL_RETURN_REASON reason, OverloadRank1)
 
template<typename T >
MAXON_ATTRIBUTE_FORCE_INLINE SFINAEHelper< T, typename NullValueFunctions< typename std::decay< T >::type >::ResultMarker >::type PrivateIncompleteNullReturnValue (NULL_RETURN_REASON reason, OverloadRank2)
 
template<typename T >
MAXON_ATTRIBUTE_FORCE_INLINE std::enable_if< STD_IS_REPLACEMENT(same, Id, typename std::decay< T >::type), T >::type PrivateIncompleteNullReturnValue (NULL_RETURN_REASON reason, OverloadRank3)
 
template<typename T >
MAXON_ATTRIBUTE_FORCE_INLINE std::enable_if< IsZeroInitialized< typename std::decay< T >::type >::value, T >::type PrivateIncompleteNullReturnValue (NULL_RETURN_REASON reason, OverloadRank4)
 
template<typename R , typename SRC , typename RESULT = typename maxon::details::CastHelper<R, SRC>::AssertCastType>
RESULT AssertCast (SRC &&ref)
 
template<typename R , typename SRC , typename RESULT = typename maxon::details::CastHelper<R, SRC>::type>
RESULT Cast (SRC &&ref)
 
template<typename R , typename SRC , typename RESULT = typename maxon::details::CastHelper<R, SRC>::type>
Result< RESULT > Cast (Result< SRC > &&src)
 
template<typename R , typename SRC , typename RESULT = typename maxon::details::CastHelper<R, SRC>::type>
Result< RESULT > AssertCast (Result< SRC > &&src)
 
 MAXON_REGISTRY (Class<>, Classes, "net.maxon.registry.classes")
 
 MAXON_REGISTRY (ClassTransformer, ClassTransformers, "net.maxon.registry.classtransformers")
 
 MAXON_DECLARATION (Class< ObjectRef >, ObjectBaseClass, "net.maxon.class.object")
 
class ComponentRoot MAXON_IF_TARGET_DEBUG (:public EmptyVirtualClass,)
 
constexpr const Char * GetFunctionName (const Char *funcName)
 
 MAXON_DECLARATION (ComponentDescriptor, ObservableCombinerRunAllComponent, "net.maxon.component.observablecombinerrunall")
 
 MAXON_DECLARATION (ComponentDescriptor, ObservableCombinerRunAllBoolOrComponent, "net.maxon.component.observablecombinerrunallboolor")
 
 MAXON_DECLARATION (ComponentDescriptor, ObservableCombinerRunAllBoolUntilFalse, "net.maxon.component.observablecombinerrunallbooluntilfalse")
 
 MAXON_DECLARATION (ComponentDescriptor, ObservableCombinerRunAllBoolUntilTrue, "net.maxon.component.observablecombinerrunallbooluntiltrue")
 
 MAXON_DECLARATION (ComponentDescriptor, ObservableCombinerRunAllEnumFlagsOrComponent, "net.maxon.component.observablecombinerrunallenumflagsor")
 
 MAXON_DECLARATION (ComponentDescriptor, ObservableCombinerRunAllEnumFlags64OrComponent, "net.maxon.component.observablecombinerrunallenumflags64or")
 
 MAXON_DECLARATION (ComponentDescriptor, ObservableCombinerRunAllAggregateErrorsComponent, "net.maxon.component.observablecombinerrunallaggregateerrors")
 
 MAXON_DECLARATION (Class< FunctionBaseRef >, FunctionBaseClass, "net.maxon.class.functionbase")
 
 MAXON_DECLARATION (Class< ObservableBaseRef >, ObservableClass, "net.maxon.class.observable")
 
 MAXON_DECLARATION (Class< ObserverObjectRef >, ObserverObjectClass, "net.maxon.class.observerobject")
 
enum maxon::NO_VALUE_TYPE MAXON_ENUM_LIST (NO_VALUE_TYPE)
 
template<typename T >
Bool operator== (const Opt< T > &lhs, const Opt< T > &rhs)
 
template<typename T >
Bool operator== (const Opt< T > &opt, NO_VALUE_TYPE)
 
template<typename T >
Bool operator== (NO_VALUE_TYPE, const Opt< T > &opt)
 
template<typename T >
Bool operator!= (const Opt< T > &opt, NO_VALUE_TYPE)
 
template<typename T >
Bool operator!= (NO_VALUE_TYPE, const Opt< T > &opt)
 
enum maxon::PARALLELFORFLAGS MAXON_ENUM_FLAGS (PARALLELFORFLAGS)
 
template<typename... ARGS>
Result< void > ParallelInvoke (Bool parallel, ARGS &&... args)
 
 MAXON_REGISTRY (ParametricType, ParametricTypes, "net.maxon.registry.parametrictypes")
 
enum maxon::PARSERFLAGS MAXON_ENUM_FLAGS (PARSERFLAGS)
 
 MAXON_REGISTRY (Class< ParserRef >, ParserClasses, "net.maxon.interface.registry.parserclasses")
 
 MAXON_DECLARATION (Class< ParserRef >, ParserBaseClass, "net.maxon.interface.parserclass.base")
 
Bool atomic_try_cas32 (Int32 volatile *dst, Int32 xchg, Int32 cmp)
 
Bool atomic_try_cas32HLE (Int32 volatile *dst, Int32 xchg, Int32 cmp)
 
Char atomic_swap_add8 (Char volatile *dst, Char value)
 
Int16 atomic_swap_add16 (Int16 volatile *dst, Int16 value)
 
Int32 atomic_swap_add32 (Int32 volatile *dst, Int32 value)
 
Char atomic_swap8 (Char volatile *dst, Char value)
 
Int16 atomic_swap16 (Int16 volatile *dst, Int16 value)
 
Int32 atomic_swap32 (Int32 volatile *dst, Int32 value)
 
Bool atomic_try_cas64 (Int64 volatile *dst, Int64 xchg, Int64 cmp)
 
Bool atomic_try_cas64HLE (Int64 volatile *dst, Int64 xchg, Int64 cmp)
 
Bool atomic_try_cas128 (Int64 volatile *dst, Int64 xchghi, Int64 xchglo, Int64 cmphi, Int64 cmplo)
 
Int64 atomic_swap_add64 (Int64 volatile *dst, Int64 value)
 
Int64 atomic_swap64 (Int64 volatile *dst, Int64 value)
 
Int32 atomic_swap_or32 (Int32 volatile *dst, Int32 mask)
 
Int32 atomic_swap_and32 (Int32 volatile *dst, Int32 mask)
 
Bool atomic_try_cas8 (Char volatile *dst, Char xchg, Char cmp)
 
Bool atomic_try_cas16 (Int16 volatile *dst, Int16 xchg, Int16 cmp)
 
Char atomic_consume_load8 (Char volatile *src)
 
Int16 atomic_consume_load16 (Int16 volatile *src)
 
Int32 atomic_consume_load32 (Int32 volatile *src)
 
Int64 atomic_consume_load64 (Int64 volatile *src)
 
Char atomic_acquire_load8 (Char volatile *src)
 
Int16 atomic_acquire_load16 (Int16 volatile *src)
 
Int32 atomic_acquire_load32 (Int32 volatile *src)
 
Int64 atomic_acquire_load64 (Int64 volatile *src)
 
Char atomic_sequential_load8 (Char volatile *src)
 
Int16 atomic_sequential_load16 (Int16 volatile *src)
 
Int32 atomic_sequential_load32 (Int32 volatile *src)
 
Int64 atomic_sequential_load64 (Int64 volatile *src)
 
void atomic_release_store8 (Char volatile *dst, Char value)
 
void atomic_release_store16 (Int16 volatile *dst, Int16 value)
 
void atomic_release_store32 (Int32 volatile *dst, Int32 value)
 
void atomic_release_store32HLE (Int32 volatile *dst, Int32 value)
 
void atomic_release_store64 (Int64 volatile *dst, Int64 value)
 
void atomic_release_store64HLE (Int64 volatile *dst, Int64 value)
 
void atomic_sequential_store8 (Char volatile *dst, Char value)
 
void atomic_sequential_store16 (Int16 volatile *dst, Int16 value)
 
void atomic_sequential_store32 (Int32 volatile *dst, Int32 value)
 
void atomic_sequential_store64 (Int64 volatile *dst, Int64 value)
 
 MAXON_DECLARATION (Class< ProgressRef >, ProgressObject, "net.maxon.image.class.mediasessionprogressobject")
 
template<typename T >
T PrivateRangeValueTypeHelper (OverloadRank0)
 
template<typename T >
T::ValueType PrivateRangeValueTypeHelper (OverloadRank1)
 
template<GET_DATATYPE_POLICY POLICY, typename T >
Result< DataType > PrivateGetDataType (Range< T > **, OverloadRank0)
 
template<typename RANGETYPE >
Int GetRangeItemCount (const RANGETYPE &data)
 
template<typename SET >
 MAXON_IMPLEMENTATION_SIMPLE_REGISTER (SetImpl< SET >)
 
template<typename T >
const SetInterface< T > * ToSetPtr (const SetInterface< T > &set)
 
template<typename T >
WritableSetInterface< T > * ToWritableSetPtr (WritableSetInterface< T > &set)
 
enum maxon::ACCESSLEVEL MAXON_ENUM_LIST (ACCESSLEVEL)
 
enum maxon::BASESORTFLAGS MAXON_ENUM_FLAGS (BASESORTFLAGS)
 
Vector4f32 LoadVector4f32 (const Vector64 &v, Float64 w, Bool aligned)
 
Vector4f32 LoadVector4f32 (const Vector32 &v, Float32 w, Bool aligned)
 
Vector4f32 LoadVector4f32 (const Vector4d64 &v, Bool aligned)
 
Vector4f32 LoadVector4f32 (const Vector4d32 &v, Bool aligned)
 
Vector4f32 LoadVector4f32 (const Color64 &v, Float64 w, Bool aligned)
 
Vector4f32 LoadVector4f32 (const Color32 &v, Float32 w, Bool aligned)
 
Vector4f32 LoadVector4f32 (const ColorA64 &v, Bool aligned)
 
Vector4f32 LoadVector4f32 (const ColorA32 &v, Bool aligned)
 
UInt64 _mm_crc32_u64 (UInt64 c, UInt64 d)
 
unsigned int _mm_crc32_u32 (UInt32 c, UInt32 d)
 
unsigned int _mm_crc32_u8 (UInt32 c, UChar d)
 
MAXON_ATTRIBUTE_FORCE_INLINE Vector4f32 CastToVector4f32 (const Vector4i32 &a)
 
MAXON_ATTRIBUTE_FORCE_INLINE Vector4f32 ConvertToVector4f32 (const Vector4i32 &a)
 
MAXON_ATTRIBUTE_FORCE_INLINE Vector4i32 CastToVector4i32 (const Vector4f32 &a)
 
MAXON_ATTRIBUTE_FORCE_INLINE Vector4i32 ConvertToVector4i32 (const Vector4f32 &a)
 
MAXON_ATTRIBUTE_FORCE_INLINE Vector4f32 ConvertToVector4f32 (const Vector2f64 &a, const Vector2f64 &b)
 
MAXON_ATTRIBUTE_FORCE_INLINE Vector4f32 ConvertToVector4f32 (const Vector2f64 &a)
 
 MAXON_REGISTRY (StreamConversionFactory, StreamConversions, "net.maxon.registry.streamconversions")
 
 MAXON_DATATYPE (ConversionTestSet, "net.maxon.datatype.conversiontestset")
 
 MAXON_REGISTRY (Factory< BaseArray< DataDictionary >()>, StreamConversionTests, "net.maxon.registry.streamconversiontests")
 
Result< void > AddConversionTestSetting (MAXON_SOURCE_LOCATION_DECLARATION, BaseArray< DataDictionary > &resultArray, const Block< const ConversionTestSet > &set, const Block< const Char > &srcData, const Block< const Char > &compareData=Block< const Char >(), Bool forbidLargeTest=false)
 
Result< void > AddConversionTestSetting (MAXON_SOURCE_LOCATION_DECLARATION, BaseArray< DataDictionary > &resultArray, const Block< const ConversionTestSet > &set, const Block< const Utf32Char > &srcData, const Block< const Char > &compareData=Block< const Char >(), Bool forbidLargeTest=false)
 
Result< void > AddConversionTestSetting (MAXON_SOURCE_LOCATION_DECLARATION, BaseArray< DataDictionary > &resultArray, const Block< const ConversionTestSet > &set, const Block< const Char > &srcData, const Block< const Utf32Char > &compareData=Block< const Utf32Char >(), Bool forbidLargeTest=false)
 
Result< void > AddConversionTestSetting (MAXON_SOURCE_LOCATION_DECLARATION, BaseArray< DataDictionary > &resultArray, const Block< const ConversionTestSet > &set, const Block< const Utf32Char > &srcData, const Block< const Utf32Char > &compareData=Block< const Utf32Char >(), Bool forbidLargeTest=false)
 
template<typename TO , typename FROM >
Factory< TO(const DataDictionary &)> & ConvertStreamConversionRef (FROM &obj)
 
 MAXON_DECLARATION (Class< StreamConversionRef >, StreamConversionBaseClass, "net.maxon.class.streamconversionbase")
 
const StringDecodingRef & GetUtf8DefaultDecoder ()
 
const StringEncodingRef & GetUtf8DefaultEncoder ()
 
enum maxon::STRINGCONVERSION MAXON_ENUM_FLAGS (STRINGCONVERSION)
 
enum maxon::STRINGCOMPARISON MAXON_ENUM_LIST (STRINGCOMPARISON)
 
const CString & operator""_cs (const char *str, std::size_t cnt)
 
Result< void > DescribeIO (const CStringInterface &s, const DataSerializeInterface &dsi)
 
Result< void > DescribeIO (const StringInterface &s, const DataSerializeInterface &dsi)
 
String operator+ (const String &a, const String &b)
 
String && operator+ (String &&a, const String &b)
 
String && operator+ (String &&a, String &&b)
 
String && operator+ (const String &a, String &&b)
 
CString operator+ (const CString &a, const CString &b)
 
CString && operator+ (CString &&a, const CString &b)
 
CString && operator+ (CString &&a, CString &&b)
 
CString && operator+ (const CString &a, CString &&b)
 
String & operator+= (String &s, const CString &b)
 
String operator+ (const String &a, const CString &b)
 
String && operator+ (String &&a, const CString &b)
 
String operator+ (const String &a, const Char *b)
 
String && operator+ (String &&a, const Char *b)
 
CString operator+ (const CString &a, const Char *b)
 
CString && operator+ (CString &&a, const Char *b)
 
String ToString (const String &str, const FormatStatement *formatStatement, Bool=false)
 
String ToString (const CString &str, const FormatStatement *formatStatement, Bool=false)
 
template<typename T >
decltype(std::declval< T >().ToString()) ToStringHelper (const T *object, const FormatStatement *formatStatement, Int *)
 
template<typename T >
String ToStringHelper (const T *object, const FormatStatement *formatStatement, const Int *checkDataType)
 
template<typename T >
std::enable_if<!STD_IS_REPLACEMENT(enum, T), String >::type ToString (const T &object, const FormatStatement *formatStatement, Bool checkDataType=true)
 
template<typename T >
std::enable_if< STD_IS_REPLACEMENT(enum, T), String >::type ToString (const T &object, const FormatStatement *formatStatement, Bool checkDataType=true)
 
template<typename T >
std::enable_if<!STD_IS_REPLACEMENT(function, T), String >::type ToString (const T *object, const FormatStatement *formatStatement)
 
const String & ToString (Bool val, const FormatStatement *formatStatement, Bool=false)
 
String ToString (Char val, const FormatStatement *formatStatement, Bool checkDataType=false)
 
String ToString (UChar val, const FormatStatement *formatStatement, Bool checkDataType=false)
 
String ToString (Int16 val, const FormatStatement *formatStatement, Bool checkDataType=false)
 
String ToString (Int32 val, const FormatStatement *formatStatement, Bool checkDataType=false)
 
String ToString (Int64 val, const FormatStatement *formatStatement, Bool checkDataType=false)
 
String ToString (UInt16 val, const FormatStatement *formatStatement, Bool checkDataType=false)
 
String ToString (UInt32 val, const FormatStatement *formatStatement, Bool checkDataType=false)
 
String ToString (UInt64 val, const FormatStatement *formatStatement, Bool checkDataType=false)
 
String ToString (Float64 val, const FormatStatement *formatStatement, Bool checkDataType=false)
 
String ToString (Float32 val, const FormatStatement *formatStatement, Bool checkDataType=false)
 
String ToString (Utf16Char val, const FormatStatement *formatStatement, Bool checkDataType=false)
 
String ToString (Utf32Char val, const FormatStatement *formatStatement, Bool checkDataType=false)
 
String ToString (Char *val, const FormatStatement *formatStatement, Bool checkDataType=false)
 
String ToString (const Char *val, const FormatStatement *formatStatement, Bool checkDataType=false)
 
String ToString (const void *val, const FormatStatement *formatStatement, Bool checkDataType=false)
 
String ToString (void *val, const FormatStatement *formatStatement, Bool checkDataType=false)
 
String ToString (const Generic *val, const FormatStatement *formatStatement, Bool checkDataType=false)
 
String ToString (Generic *val, const FormatStatement *formatStatement, Bool checkDataType=false)
 
String ExtractString (StringProxy *proxy)
 
const String & ExtractString (const String &str)
 
const Char * ExtractString (const Char *str)
 
void ScanParameter (Float64 &result, const Block< const Utf32Char > &str, Int &processed, const String &formatStatement, Bool &error)
 
void ScanParameter (Float32 &result, const Block< const Utf32Char > &str, Int &processed, const String &formatStatement, Bool &error)
 
void ScanParameter (Int64 &result, const Block< const Utf32Char > &str, Int &processed, const String &formatStatement, Bool &error)
 
void ScanParameter (Int32 &result, const Block< const Utf32Char > &str, Int &processed, const String &formatStatement, Bool &error)
 
void ScanParameter (Int16 &result, const Block< const Utf32Char > &str, Int &processed, const String &formatStatement, Bool &error)
 
void ScanParameter (Char &result, const Block< const Utf32Char > &str, Int &processed, const String &formatStatement, Bool &error)
 
void ScanParameter (UInt64 &result, const Block< const Utf32Char > &str, Int &processed, const String &formatStatement, Bool &error)
 
void ScanParameter (UInt32 &result, const Block< const Utf32Char > &str, Int &processed, const String &formatStatement, Bool &error)
 
void ScanParameter (UInt16 &result, const Block< const Utf32Char > &str, Int &processed, const String &formatStatement, Bool &error)
 
void ScanParameter (UChar &result, const Block< const Utf32Char > &str, Int &processed, const String &formatStatement, Bool &error)
 
template<typename T >
void ScanParameter (T *&result, const Block< const Utf32Char > &str, Int &processed, const String &formatStatement, Bool &error)
 
template<typename T >
void FromStrHlp (T *result, const Block< const Utf32Char > &str, Int &processed, const String &formatStatement, Bool &error)
 
template<typename T >
FROMSTR GetFromStrHlp ()
 
Bool ScanStringTemplate (const String &str, const String &format, Int *parsedCharacters, Int argsCnt, void **args, FROMSTR *argFuncs)
 
CString ExtractCString (StringProxy *proxy)
 
template<Bool ISOKAY, typename T >
MAXON_ATTRIBUTE_FORCE_INLINE T ForwardString (T &&str)
 
template<typename STR , typename STR2 , typename... ARGS>
Bool ScanString (STR inputStr, STR2 formatStr, ARGS &... args)
 
template<typename STR , typename STR2 , typename... ARGS>
Bool ScanString (STR inputStr, Int &parsedInputCharacters, STR2 formatStr, ARGS &... args)
 
String _LoadResourceString (const Id &scope, const InternedId &keyValue)
 
template<typename STRID , typename... ARGUMENTS>
String LoadResourceString (const STRID &identifier, const ARGUMENTS &... args)
 
static Int StrLen (const SysChar *chr)
 
static Int StrLen (const Utf32Char *chr)
 
static Int StrLen (const Utf16Char *chr)
 
template<typename TYPE >
MAXON_ATTRIBUTE_FORCE_INLINE Bool IsSpace (TYPE chr)
 
template<typename TYPE >
MAXON_ATTRIBUTE_FORCE_INLINE Bool IsTab (TYPE chr)
 
template<typename TYPE >
MAXON_ATTRIBUTE_FORCE_INLINE Bool IsSpaceOrTab (TYPE chr)
 
template<typename TYPE >
MAXON_ATTRIBUTE_FORCE_INLINE Bool IsLineEnd (TYPE chr)
 
template<typename TYPE >
MAXON_ATTRIBUTE_FORCE_INLINE Bool IsNumeric (TYPE chr)
 
template<typename TYPE >
MAXON_ATTRIBUTE_FORCE_INLINE Bool IsAlphabetic (TYPE chr)
 
template<typename TYPE >
MAXON_ATTRIBUTE_FORCE_INLINE Bool IsAlphanumeric (TYPE chr)
 
template<typename TYPE >
MAXON_ATTRIBUTE_FORCE_INLINE Bool IsHexadecimal (TYPE chr)
 
template<typename TYPE >
MAXON_ATTRIBUTE_FORCE_INLINE Int GetHexadecimalValue (TYPE chr)
 
template<typename ITERATABLETYPE , typename REFTYPE >
static MAXON_WARN_UNUSED REFTYPE JoinElements (ITERATABLETYPE &&iterable, const REFTYPE &delimiter, const FormatStatement *formatStr=nullptr)
 
template<typename STRINGTYPE >
void AppendStringWithSeparator (STRINGTYPE &base, const STRINGTYPE &add, const STRINGTYPE &delimiter)
 
template<typename STRINGTYPE >
STRINGTYPE AddStringWithSeparator (const STRINGTYPE &base, const STRINGTYPE &add, const STRINGTYPE &delimiter)
 
 MAXON_REGISTRY (StringEncodingRef, StringEncodings, "net.maxon.registry.stringencodings")
 
 MAXON_REGISTRY (StringDecodingRef, StringDecodings, "net.maxon.registry.stringdecodings")
 
 MAXON_MEMBERFUNCTION_DETECTOR (GetReferenceCounter)
 
enum maxon::EXECUTEPROGRAMFLAGS MAXON_ENUM_FLAGS (EXECUTEPROGRAMFLAGS)
 
enum maxon::EXECUTEPROGRAMCALLBACK MAXON_ENUM_LIST (EXECUTEPROGRAMCALLBACK)
 
enum maxon::WAIT_PROCESS_RESULT MAXON_ENUM_LIST (WAIT_PROCESS_RESULT)
 
 MAXON_DECLARATION (Class< SystemProcessObjectRef >, SystemProcessObjectClass, "net.maxon.class.systemprocessobject")
 
template<typename T , typename HANDLER , typename TAG , Int TAG_BITS, TAG DEFAULT_VALUE, Bool ENABLE_POINTER_CONVERSION>
SFINAEHelper< String, T >::type ToString (const TaggedBaseRef< T, HANDLER, TAG, TAG_BITS, DEFAULT_VALUE, ENABLE_POINTER_CONVERSION > &object, const FormatStatement *formatStatement, Bool checkDataType=true)
 
 MAXON_DATATYPE (ThreadRef, "net.maxon.datatype.threadref")
 
enum maxon::THREADPRIORITY Int16 MAXON_ENUM_LIST (THREADPRIORITY)
 
enum maxon::WAITMODE MAXON_ENUM_FLAGS (WAITMODE)
 
enum maxon::THREADTYPE MAXON_ENUM_LIST (THREADTYPE)
 
enum maxon::TIMEFORMAT MAXON_ENUM_LIST (TIMEFORMAT)
 
const TimeValue operator""_h (long double value)
 
const TimeValue operator""_min (long double value)
 
const TimeValue operator""_sec (long double value)
 
const TimeValue operator""_ms (long double value)
 
const TimeValue operator""_us (long double value)
 
const TimeValue operator""_ns (long double value)
 
 MAXON_DATATYPE (TimeValue, "net.maxon.datatype.timevalue")
 
template<Int I, typename ... TYPES>
auto TupleGet (const Tuple< TYPES ... > &tup) -> const typename ParameterPack< TYPES... >::template At< I >::type &
 
template<Int I, typename ... TYPES>
auto TupleGet (Tuple< TYPES ... > &tup) -> typename ParameterPack< TYPES... >::template At< I >::type &
 
template<Int I, typename ... TYPES>
auto TupleGet (Tuple< TYPES ... > &&tup) -> typename ParameterPack< TYPES... >::template At< I >::type &&
 
template<typename F , typename ... TYPES>
auto TupleExpand (const Tuple< TYPES ... > &tup, F &&func) -> decltype(maxon::details::ExpandSeqHelperConst(tup, std::forward< F >(func), std::make_index_sequence< sizeof...(TYPES)>()))
 
template<typename F , typename ... TYPES>
auto TupleExpand (Tuple< TYPES ... > &tup, F &&func) -> decltype(maxon::details::ExpandSeqHelper(tup, std::forward< F >(func), std::make_index_sequence< sizeof...(TYPES)>()))
 
template<typename F , typename ... TYPES>
auto TupleExpand (Tuple< TYPES ... > &&tup, F &&func) -> decltype(maxon::details::ExpandSeqHelper(std::move(tup), std::forward< F >(func), std::make_index_sequence< sizeof...(TYPES)>()))
 
template<typename ... TYPES>
auto ToTuple (TYPES &&... args) -> Tuple< typename std::decay< TYPES >::type ... >
 
template<typename... TYPES>
auto Tie (TYPES &... args) -> Tuple< TYPES &... >
 
template<typename... TYPES>
auto ToForwardTuple (TYPES &&... args) -> Tuple< TYPES &&... >
 
template<typename F , typename ... TYPES>
void TupleForEach (const Tuple< TYPES ... > &tup, F &&func)
 
template<typename F , typename ... TYPES>
void TupleForEach (Tuple< TYPES ... > &tup, F &&func)
 
template<typename F , typename ... TYPES>
void TupleForEach (Tuple< TYPES ... > &&tup, F &&func)
 
template<typename V , typename F , typename ... TYPES>
auto TupleFold (const Tuple< TYPES ... > &tup, const V &initialValue, F &&func) -> V
 
template<typename V , typename F , typename ... TYPES>
auto TupleFold (Tuple< TYPES ... > &tup, const V &initialValue, F &&func) -> V
 
template<typename V , typename F , typename ... TYPES>
auto TupleFold (Tuple< TYPES ... > &&tup, const V &initialValue, F &&func) -> V
 
template<typename T >
MAXON_ATTRIBUTE_FORCE_INLINE Id GetTypeName ()
 
enum maxon::NORMALIZATION MAXON_ENUM_LIST (NORMALIZATION)
 
enum maxon::CHARACTERTYPE UChar MAXON_ENUM_LIST (CHARACTERTYPE)
 
template<typename TYPE >
MAXON_ATTRIBUTE_FORCE_INLINE Bool IsUnicodeLetter (TYPE chr)
 
enum maxon::BASE_DIMENSION MAXON_ENUM_LIST (BASE_DIMENSION)
 
 MAXON_REGISTRY (Dimension, Dimensions, "net.maxon.registry.dimensions")
 
 MAXON_REGISTRY (Unit, Units, "net.maxon.registry.units")
 
class IoConnectionRef MAXON_FORWARD ("maxon/ioconnection.h")
 
class IoBrowseRef MAXON_FORWARD ("maxon/iobrowse.h")
 
class UniversalDateTime MAXON_FORWARD ("maxon/datetime.h")
 
enum maxon::GETBROWSEITERATORFLAGS MAXON_ENUM_FLAGS (GETBROWSEITERATORFLAGS)
 
enum maxon::CONVERTTOUINAMEFLAGS MAXON_ENUM_FLAGS (CONVERTTOUINAMEFLAGS)
 
 MAXON_REGISTRY (UrlIoShowInOSDelegate, UrlIoShowInOSRegistry, "net.maxon.registry.urlioshowinos")
 
enum maxon::URLFILECACHEFLAGS MAXON_ENUM_FLAGS (URLFILECACHEFLAGS)
 
MAXON_ATTRIBUTE_FORCE_INLINE Float32 Clamp01 (Float32 a)
 
MAXON_ATTRIBUTE_FORCE_INLINE Float64 Clamp01 (Float64 a)
 
MAXON_ATTRIBUTE_FORCE_INLINE Float32 Sin (Float32 val)
 
MAXON_ATTRIBUTE_FORCE_INLINE Float64 Sin (Float64 val)
 
MAXON_ATTRIBUTE_FORCE_INLINE Float32 Cos (Float32 val)
 
MAXON_ATTRIBUTE_FORCE_INLINE Float64 Cos (Float64 val)
 
MAXON_ATTRIBUTE_FORCE_INLINE Float32 Tan (Float32 val)
 
MAXON_ATTRIBUTE_FORCE_INLINE Float64 Tan (Float64 val)
 
MAXON_ATTRIBUTE_FORCE_INLINE Float32 ATan (Float32 val)
 
MAXON_ATTRIBUTE_FORCE_INLINE Float64 ATan (Float64 val)
 
MAXON_ATTRIBUTE_FORCE_INLINE Float32 ATan2 (Float32 valY, Float32 valX)
 
MAXON_ATTRIBUTE_FORCE_INLINE Float64 ATan2 (Float64 valY, Float64 valX)
 
MAXON_ATTRIBUTE_FORCE_INLINE Float32 Exp (Float32 val)
 
MAXON_ATTRIBUTE_FORCE_INLINE Float64 Exp (Float64 val)
 
MAXON_ATTRIBUTE_FORCE_INLINE Float32 Exp2 (Float32 val)
 
MAXON_ATTRIBUTE_FORCE_INLINE Float64 Exp2 (Float64 val)
 
MAXON_ATTRIBUTE_FORCE_INLINE Float32 Ln (Float32 val)
 
MAXON_ATTRIBUTE_FORCE_INLINE Float64 Ln (Float64 val)
 
MAXON_ATTRIBUTE_FORCE_INLINE Float32 Log10 (Float32 val)
 
MAXON_ATTRIBUTE_FORCE_INLINE Float64 Log10 (Float64 val)
 
MAXON_ATTRIBUTE_FORCE_INLINE Float32 Log2 (Float32 val)
 
MAXON_ATTRIBUTE_FORCE_INLINE Float64 Log2 (Float64 val)
 
MAXON_ATTRIBUTE_FORCE_INLINE Float32 Sqrt (Float32 val)
 
MAXON_ATTRIBUTE_FORCE_INLINE Float64 Sqrt (Float64 val)
 
MAXON_ATTRIBUTE_FORCE_INLINE Float32 Floor (Float32 val)
 
MAXON_ATTRIBUTE_FORCE_INLINE Float64 Floor (Float64 val)
 
MAXON_ATTRIBUTE_FORCE_INLINE Float32 Ceil (Float32 val)
 
MAXON_ATTRIBUTE_FORCE_INLINE Float64 Ceil (Float64 val)
 
MAXON_ATTRIBUTE_FORCE_INLINE Float32 Round (Float32 val)
 
MAXON_ATTRIBUTE_FORCE_INLINE Float64 Round (Float64 val)
 
MAXON_ATTRIBUTE_FORCE_INLINE Float32 Pow (Float32 v1, Float32 v2)
 
MAXON_ATTRIBUTE_FORCE_INLINE Float64 Pow (Float64 v1, Float64 v2)
 
MAXON_ATTRIBUTE_FORCE_INLINE Float32 Sinh (Float32 val)
 
MAXON_ATTRIBUTE_FORCE_INLINE Float64 Sinh (Float64 val)
 
MAXON_ATTRIBUTE_FORCE_INLINE Float32 Cosh (Float32 val)
 
MAXON_ATTRIBUTE_FORCE_INLINE Float64 Cosh (Float64 val)
 
MAXON_ATTRIBUTE_FORCE_INLINE Float32 Tanh (Float32 val)
 
MAXON_ATTRIBUTE_FORCE_INLINE Float64 Tanh (Float64 val)
 
MAXON_ATTRIBUTE_FORCE_INLINE Float32 FMod (Float32 v1, Float32 v2)
 
MAXON_ATTRIBUTE_FORCE_INLINE Float64 FMod (Float64 v1, Float64 v2)
 
MAXON_ATTRIBUTE_FORCE_INLINE Float32 Abs (Float32 val)
 
MAXON_ATTRIBUTE_FORCE_INLINE Float64 Abs (Float64 val)
 
MAXON_ATTRIBUTE_FORCE_INLINE Float32 Inverse (Float32 f)
 
MAXON_ATTRIBUTE_FORCE_INLINE Float64 Inverse (Float64 f)
 
template<typename X >
constexpr MAXON_ATTRIBUTE_FORCE_INLINE X Abs (X f)
 
template<typename X >
constexpr MAXON_ATTRIBUTE_FORCE_INLINE X Min (X a, X b)
 
template<typename X >
constexpr MAXON_ATTRIBUTE_FORCE_INLINE X Max (X a, X b)
 
template<typename X >
MAXON_ATTRIBUTE_FORCE_INLINE void Swap (X &a, X &b)
 
template<typename X >
MAXON_ATTRIBUTE_FORCE_INLINE X ClampValue (X value, X lowerLimit, X upperLimit)
 
template<typename X , typename Y >
MAXON_ATTRIBUTE_FORCE_INLINE X Blend (const X &value1, const X &value2, Y blendValue)
 
template<typename X >
MAXON_ATTRIBUTE_FORCE_INLINE X Sqr (X a, X b)
 
template<typename X >
MAXON_ATTRIBUTE_FORCE_INLINE X Sqr (X a)
 
MAXON_ATTRIBUTE_FORCE_INLINE Float32 Gamma (Float32 value, Float32 gamma)
 
MAXON_ATTRIBUTE_FORCE_INLINE Float64 Gamma (Float64 value, Float64 gamma)
 
MAXON_ATTRIBUTE_FORCE_INLINE Float32 Si (Float32 val)
 
MAXON_ATTRIBUTE_FORCE_INLINE Float64 Si (Float64 val)
 
MAXON_ATTRIBUTE_FORCE_INLINE Float32 Sinc (Float32 val)
 
MAXON_ATTRIBUTE_FORCE_INLINE Float64 Sinc (Float64 val)
 
MAXON_ATTRIBUTE_FORCE_INLINE Float32 ASin (Float32 val)
 
MAXON_ATTRIBUTE_FORCE_INLINE Float64 ASin (Float64 val)
 
MAXON_ATTRIBUTE_FORCE_INLINE Float32 ACos (Float32 val)
 
MAXON_ATTRIBUTE_FORCE_INLINE Float64 ACos (Float64 val)
 
MAXON_ATTRIBUTE_FORCE_INLINE Float32 DegToRad (Float32 r)
 
MAXON_ATTRIBUTE_FORCE_INLINE Float64 DegToRad (Float64 r)
 
MAXON_ATTRIBUTE_FORCE_INLINE Float32 RadToDeg (Float32 r)
 
MAXON_ATTRIBUTE_FORCE_INLINE Float64 RadToDeg (Float64 r)
 
MAXON_ATTRIBUTE_FORCE_INLINE void SinCos (Float32 val, Float32 &sn, Float32 &cs)
 
MAXON_ATTRIBUTE_FORCE_INLINE void SinCos (Float64 val, Float64 &sn, Float64 &cs)
 
template<typename DEST >
MAXON_ATTRIBUTE_FORCE_INLINE DEST SafeConvert (Float64 src)
 
template<typename DEST >
MAXON_ATTRIBUTE_FORCE_INLINE DEST SafeConvert (Float32 src)
 
template<typename T >
MAXON_ATTRIBUTE_FORCE_INLINE void SetMax (T &a, const typename SFINAEHelper< T >::type &b)
 
template<typename T >
MAXON_ATTRIBUTE_FORCE_INLINE void SetMin (T &a, const typename SFINAEHelper< T >::type &b)
 
template<typename X >
MAXON_ATTRIBUTE_FORCE_INLINE Int Sign (X f)
 
template<typename T >
MAXON_ATTRIBUTE_FORCE_INLINE T Mod (T a, T b)
 
constexpr MAXON_ATTRIBUTE_FORCE_INLINE Bool IsPowerOfTwo (UInt32 x)
 
constexpr MAXON_ATTRIBUTE_FORCE_INLINE Bool IsPowerOfTwo (UInt64 x)
 
template<Bool SKIPERRORS = false, typename FN , typename SRC , typename DST >
Result< void > MoveFromWithFilter (DST &dst, SRC &src, const FN &filter)
 
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)
 
enum maxon::TARGETAUDIENCE MAXON_ENUM_FLAGS (TARGETAUDIENCE, "net.maxon.datatype.enum.targetaudience", EARLY)
 
enum maxon::WRITEMETA MAXON_ENUM_FLAGS (WRITEMETA, "net.maxon.datatype.enum.writemeta", EARLY)
 
enum maxon::OUTPUT MAXON_ENUM_FLAGS (OUTPUT, "net.maxon.datatype.enum.output", EARLY)
 
void _ConsoleOutput (OUTPUT flags, const Char *str, Int line, const Char *file)
 
void _ConsoleOutput (OUTPUT flags, const String &str, Int line, const Char *file)
 
void _ConsoleOutput (OUTPUT flags, StringProxy *str, Int line, const Char *file)
 
void _ApplicationOutput (maxon::TARGETAUDIENCE t, maxon::WRITEMETA lvl, const maxon::String &str, Int line, const Char *file)
 
void _ApplicationOutput (maxon::TARGETAUDIENCE t, maxon::WRITEMETA lvl, const Char *str, Int line, const Char *file)
 
void _ApplicationOutput (maxon::TARGETAUDIENCE t, maxon::WRITEMETA lvl, const maxon::StringProxy *proxy, Int line, const Char *file)
 
template<typename T >
void ToStrHlp (String &result, const T *x, const FormatStatement *formatStatement)
 
template<typename T >
TOSTR GetToStrHlp ()
 
StringProxy * Format (const String &formatString, Int argsCnt, const void **args, const TOSTR *argFuncs)
 
StringProxy * Format (const Char *formatString, Int argsCnt, const void **args, const TOSTR *argFuncs)
 
template<Int ARGCNT, typename FORMATSTR , typename... ARGS>
StringProxy * FormatTemplateX (FORMATSTR formatString, const ARGS &... args)
 
template<Int ARGCNT, typename FORMATSTR >
FORMATSTR FormatTemplateX (FORMATSTR formatString)
 
constexpr Int GetArgCnt (const Char *const formatStr)
 
String GetPrintableString (JNIEnv *env, const jstring &val)
 
static String ToString (JNIEnv *env, const jstring &str)
 
template<typename T >
static MAXON_ATTRIBUTE_FORCE_INLINE const Char * PrivateGetClassName ()
 
template<typename T >
Result< CopyWrapper< typename std::decay< T >::type > > CreateCopyWrapper (T &&src)
 
template<typename T , typename... ARGS>
ResultPtr< T > NewObjT (ARGS &&... args)
 
template<typename T >
MAXON_ATTRIBUTE_FORCE_INLINE void DeleteConstPtrObj (T *o)
 
enum maxon::ERROR_OK MAXON_ENUM_LIST (ERROR_OK)
 
enum maxon::ERROR_FAILED MAXON_ENUM_LIST (ERROR_FAILED)
 
enum maxon::ERROR_TYPE MAXON_ENUM_LIST (ERROR_TYPE)
 
const Error * CreateErrorPtr (MAXON_SOURCE_LOCATION_DECLARATION, ERROR_TYPE type) __attribute__((pure
 
ThreadReferencedError CreateError (MAXON_SOURCE_LOCATION_DECLARATION, ERROR_TYPE type)
 
const Error * PrivateSystemSetCurrentError (const Error &error)
 
const Error * PrivateSystemSetCurrentError (Error &&error)
 
void PrivateSetError (Error &dest, const Error *src)
 
 MAXON_MEMBERTYPE_DETECTOR (IsForwardRef, IsForwardRef, std::false_type)
 
template<typename T >
MAXON_ATTRIBUTE_FORCE_INLINE auto operator% (const ResultOk< T > &rv, ThreadReferencedError &err) -> decltype(rv.GetValue())
 
template<typename T >
MAXON_ATTRIBUTE_FORCE_INLINE T operator% (ResultOk< T > &&rv, ThreadReferencedError &err)
 
template<typename T >
MAXON_ATTRIBUTE_FORCE_INLINE T & operator% (ResultOk< T & > &&rv, ThreadReferencedError &err)
 
MAXON_ATTRIBUTE_FORCE_INLINE void operator% (ResultOk< void > &&rv, ThreadReferencedError &err)
 
template<typename T >
MAXON_ATTRIBUTE_FORCE_INLINE auto operator% (const ResultOk< T > &rv, maxon::details::ResultOkError &err) -> decltype(rv.GetValue())
 
template<typename T >
MAXON_ATTRIBUTE_FORCE_INLINE T operator% (ResultOk< T > &&rv, maxon::details::ResultOkError &err)
 
template<typename T >
MAXON_ATTRIBUTE_FORCE_INLINE T & operator% (ResultOk< T & > &&rv, maxon::details::ResultOkError &err)
 
MAXON_ATTRIBUTE_FORCE_INLINE void operator% (ResultOk< void > &&rv, maxon::details::ResultOkError &err)
 
template<typename T >
MAXON_ATTRIBUTE_FORCE_INLINE auto operator% (const Result< T > &rv, ThreadReferencedError &err) -> decltype(rv.GetValue())
 
template<typename T >
MAXON_ATTRIBUTE_FORCE_INLINE T operator% (Result< T > &&rv, ThreadReferencedError &err)
 
template<typename T >
MAXON_ATTRIBUTE_FORCE_INLINE T & operator% (const Result< T & > &rv, ThreadReferencedError &err)
 
template<typename T >
MAXON_ATTRIBUTE_FORCE_INLINE T & operator% (Result< T & > &&rv, ThreadReferencedError &err)
 
MAXON_ATTRIBUTE_FORCE_INLINE void operator% (const Result< void > &rv, ThreadReferencedError &err)
 
MAXON_ATTRIBUTE_FORCE_INLINE void operator% (Result< void > &&rv, ThreadReferencedError &err)
 
template<typename T >
MAXON_ATTRIBUTE_FORCE_INLINE T && operator% (ResultMemT< T > &&ptr, ThreadReferencedError &err)
 
template<typename T >
MAXON_ATTRIBUTE_FORCE_INLINE const T & operator% (const ResultMemT< T > &ptr, ThreadReferencedError &err)
 
template<typename T >
MAXON_ATTRIBUTE_FORCE_INLINE T & operator% (ResultRef< T > ptr, ThreadReferencedError &err)
 
void SetSplashMessage (const String &text)
 
void SetSplashImage (const Url &url)
 
void SetSplashStartBlocking ()
 
void SetSplashShow (Bool show)
 
static MAXON_ATTRIBUTE_FORCE_INLINE void DebugPrint (const String &str)
 
static void FreeThreadedStuff ()
 
MAXON_ATTRIBUTE_FORCE_INLINE ColorA IntToColor (UInt r, UInt g, UInt b, UInt a)
 
MAXON_ATTRIBUTE_FORCE_INLINE ColorA IntToColor (UInt r, UInt g, UInt b)
 
MAXON_ATTRIBUTE_FORCE_INLINE ColorA FloatToColor (Float r, Float g, Float b, Float a)
 
MAXON_ATTRIBUTE_FORCE_INLINE ColorA FloatToColor (Float r, Float g, Float b)
 
MAXON_ATTRIBUTE_FORCE_INLINE ColorA ColorSetAlpha (const ColorA &col, Float alpha)
 
MAXON_ATTRIBUTE_FORCE_INLINE ColorA ColorMultiplyAlpha (const ColorA &col, Float alpha)
 
MAXON_ATTRIBUTE_FORCE_INLINE Color BlendColors (const Color &col1, const Color &col2, Float alpha)
 
MAXON_ATTRIBUTE_FORCE_INLINE ColorA BlendColors (const ColorA &col1, const ColorA &col2, Float alpha)
 
template<typename COLORTYPE >
MAXON_ATTRIBUTE_FORCE_INLINE COLORTYPE BlendColor (const COLORTYPE &col1, const COLORTYPE &col2, const typename COLORTYPE::ValueType blendValue)
 
MAXON_ATTRIBUTE_FORCE_INLINE Float GetPerceivedBrightness (const ColorA &color)
 
MAXON_ATTRIBUTE_FORCE_INLINE Bool IsColorPerceivedAsDark (const ColorA &color)
 
 MAXON_ASSERT_STANDARD_LAYOUT (WeakRefBase)
 
 MAXON_ASSERT_STANDARD_LAYOUT (WeakRefTargetBase)
 
enum maxon::MEMORY_OBSERVER_FLAGS Int MAXON_ENUM_FLAGS (MEMORY_OBSERVER_FLAGS)
 
enum maxon::MEMORY_OBSERVER_STATE Int MAXON_ENUM_FLAGS (MEMORY_OBSERVER_STATE)
 
MAXON_ATTRIBUTE_FORCE_INLINE Error GetHResultError (HRESULT hr, MAXON_SOURCE_LOCATION_DECLARATION)
 
MAXON_ATTRIBUTE_FORCE_INLINE void operator% (HRESULT value, ThreadReferencedError &err)
 
MAXON_ATTRIBUTE_FORCE_INLINE Result< Int64 > PropVariantToInt64 (const PROPVARIANT &vt)
 
MAXON_ATTRIBUTE_FORCE_INLINE Result< Int64 > VariantToInt64 (const VARIANT &vt)
 
MAXON_ATTRIBUTE_FORCE_INLINE Result< UniversalDateTime > PropVariantToUniversalDateTime (const PROPVARIANT &vt)
 
MAXON_ATTRIBUTE_FORCE_INLINE Result< UniversalDateTime > VariantToUniversalDateTime (const VARIANT &vt)
 
UniversalDateTime ConvertSystemTimeToUniversalDateTime (const SYSTEMTIME &st)
 
UInt64 FiletimeToUnixTimestamp (const FILETIME &ft)
 
static Result< UniversalDateTime > ConvertFileTimeToUniversalDateTime (const FILETIME &fd, Bool filetimeIsUtc)
 
SYSTEMTIME ConvertUniversalDateTimeToSystemTime (const UniversalDateTime &dateTime)
 
FILETIME ConvertUniversalDateTimeToFileTime (const UniversalDateTime &dateTime)
 
template<>
DestructorPointer GetDestructorPointer< corenodes::FrameData > ()
 
enum maxon::BLOCK_CIPHER_MODE UInt64 MAXON_ENUM_FLAGS (BLOCK_CIPHER_MODE)
 
Result< String > GetHashString (const BaseArray< UChar > &hashValue)
 
Result< String > GetPasswordHash (const String &password, const StreamConversionFactory &hashClass, const DataDictionary &settings=DataDictionary())
 
Result< String > GetPasswordHash (const Block< const Char > &password, const StreamConversionFactory &hashClass, const DataDictionary &settings=DataDictionary())
 
Result< Tuple< String, String > > HashPasswordWithSalt (const String &password, const StreamConversionFactory &hashClass=StreamConversions::HashSHA256())
 
Result< void > AddConversionTestSetting (MAXON_SOURCE_LOCATION_DECLARATION, BaseArray< DataDictionary > &resultArray, const Id &encoderId, const Id &decoderId, Int blockSizeBits, const void *key1, Int key1BitSize, const void *key2=nullptr, Int key2BitSize=0, UInt64 flags=0, BLOCK_CIPHER_CTR_CALLBACK &&callback=BLOCK_CIPHER_CTR_CALLBACK(), const Char *srcData=nullptr, const Char *compareData=nullptr)
 
 MAXON_REGISTRY (Class< ConvexDecompositionRef >, ConvexDecompositionClasses, "net.maxon.registry.convexdecompositionclasses")
 
enum maxon::GEOMETRY_TEST_EXACT MAXON_ENUM_LIST (GEOMETRY_TEST_EXACT)
 
enum maxon::LOOP_OVERLAP_STATE MAXON_ENUM_LIST (LOOP_OVERLAP_STATE)
 
enum maxon::GRAPH_TYPE MAXON_ENUM_LIST (GRAPH_TYPE)
 
 MAXON_REGISTRY (InterpolateType, InterpolateTypes, "net.maxon.geometry.registry.interpolation.types")
 
 MAXON_DATATYPE (SimplePolygon, "net.maxon.geom.simplepolygon")
 
 MAXON_DATATYPE (UVWPolygon, "net.maxon.geom.uvwpolygon")
 
template<typename INDEXTYPE , typename COUNT >
INDEXTYPE GetPredecessor (INDEXTYPE index, COUNT vertexCount)
 
template<typename INDEXTYPE , typename COUNT >
INDEXTYPE GetSuccessor (INDEXTYPE index, COUNT vertexCount)
 
enum maxon::WIRE_MODE UChar MAXON_ENUM_ORDERED_FLAGS (WIRE_MODE)
 
 MAXON_DATATYPE (Wires, "net.maxon.graph.wires")
 
enum maxon::CONNECTION_POSITION MAXON_ENUM_ORDERED_LIST (CONNECTION_POSITION)
 
CONNECTION_POSITION Reverse (CONNECTION_POSITION pos)
 
 MAXON_DATATYPE (GraphTransaction, "net.maxon.graph.graphtransaction")
 
 MAXON_DATATYPE (GraphNode, "net.maxon.graph.graphnode")
 
PORT_DIR GetConnectionDirection (const GraphNode &port)
 
 MAXON_ATTRIBUTE (DataDictionary, GraphNodeSelection, "net.maxon.mvp.graphnodeselection")
 
 MAXON_ATTRIBUTE (DataDictionary, GraphPortSelection, "net.maxon.mvp.graphportselection")
 
 MAXON_ATTRIBUTE (DataDictionary, GraphWireSelection, "net.maxon.mvp.graphwireselection")
 
template<typename ATTR , typename PRES , typename SEL >
static Result< void > SetGraphSelection (const GraphNode &root, const SEL &selection, SELECTION_MODE mode, const DataDictionary &userData)
 
 MAXON_ATTRIBUTE (Int, OrderIndex, "orderindex")
 
 MAXON_ATTRIBUTE (Int, InsertIndex, "insertindex")
 
 MAXON_ATTRIBUTE (Data, DefaultValue, "default")
 
 MAXON_ATTRIBUTE (Data, ConstantValue, "constant")
 
 MAXON_ATTRIBUTE (String, EffectiveName, "effectivename")
 
enum maxon::NODE_KIND MAXON_ENUM_FLAGS (NODE_KIND)
 
PORT_DIR GetPortDirection (NODE_KIND kind)
 
Bool operator== (const PathBlock &a, const NodePathInterface *b)
 
Bool operator!= (const PathBlock &a, const NodePathInterface *b)
 
Bool operator== (const NodePathInterface *b, const PathBlock &a)
 
Bool operator!= (const NodePathInterface *b, const PathBlock &a)
 
Bool operator>= (const PathBlock &a, const NodePathInterface *b)
 
Bool operator< (const PathBlock &a, const NodePathInterface *b)
 
Bool operator> (const PathBlock &a, const NodePathInterface *b)
 
Bool operator<= (const PathBlock &a, const NodePathInterface *b)
 
Result< NodePath > operator+ (const PathBlock &a, const NodePath &b)
 
 MAXON_DECLARATION (Class< AudioObjectRef >, AudioObjectClass, "net.maxon.image.class.audioobject")
 
 MAXON_DATATYPE (DrawDimensionInt, "net.maxon.image.drawdimensionint")
 
 MAXON_DATATYPE (DrawDimensionFloat, "net.maxon.image.drawdimensionfloat")
 
 MAXON_DATATYPE (DrawRectInt, "net.maxon.image.drawrectint")
 
 MAXON_DATATYPE (DrawRectFloat, "net.maxon.image.drawrectfloat")
 
 MAXON_DATATYPE (DrawPoint3dInt, "net.maxon.image.drawpoint3dint")
 
 MAXON_DATATYPE (DrawPoint3dFloat, "net.maxon.image.drawpoint3dfloat")
 
 MAXON_DATATYPE (DrawDimension3dInt, "net.maxon.image.drawdimension3dint")
 
 MAXON_DATATYPE (DrawDimension3dFloat, "net.maxon.image.drawdimension3dfloat")
 
 MAXON_DATATYPE (DrawVolumeInt, "net.maxon.image.drawvolumeint")
 
 MAXON_DATATYPE (DrawVolumeFloat, "net.maxon.image.drawvolumefloat")
 
enum maxon::IMAGEHIERARCHY MAXON_ENUM_LIST (IMAGEHIERARCHY)
 
const Class< ImagePixelStorage > & GetNormalPixelStorageClass ()
 
 MAXON_REGISTRY (Class< ImageBaseRef >, ImageBaseClasses, "net.maxon.image.registry.imagebaseclasses")
 
 MAXON_REGISTRY (Class< ImageTextureRef >, ImageTextureClasses, "net.maxon.image.registry.imagetextureclasses")
 
 MAXON_REGISTRY (Class< ImageRef >, ImageClasses, "net.maxon.image.registry.imageclasses")
 
 MAXON_REGISTRY (Class< ImageLayerRef >, ImageLayerClasses, "net.maxon.image.registry.imagelayerclasses")
 
ImageRef GetImageOf (const ImageBaseRef &bmp)
 
ImageLayerRef GetFirstAlphaOf (const ImageBaseRef &bmp)
 
Result< void > ConvertImageSequence (const Url &sourceUrl, const Url &destPath, const String &destFilePatern, const Class< MediaOutputUrlRef > &exportClass, const ValueReceiver< const Url & > &resultFiles)
 
Result< void > CopyImageData (const ImageBaseRef &source, const ImageRef &dest, Bool allowDifferentSize)
 
 MAXON_DATATYPE (BITS, "net.maxon.image.bits")
 
enum maxon::COLORPROFILEINFO MAXON_ENUM_LIST (COLORPROFILEINFO)
 
enum maxon::COLORCONVERSIONINTENT MAXON_ENUM_LIST (COLORCONVERSIONINTENT)
 
enum maxon::COLORCONVERSIONFLAGS MAXON_ENUM_FLAGS (COLORCONVERSIONFLAGS)
 
template<typename T >
T SRGBtoLinear (const T &v)
 
template<typename T >
T LinearToSRGB (const T &v)
 
 MAXON_REGISTRY (ColorProfile, ColorProfiles, "net.maxon.image.registry.colorprofiles")
 
 MAXON_REGISTRY (ColorSpace, ColorSpaces, "net.maxon.image.registry.colorspaces")
 
 MAXON_DATATYPE (Pix16f, "net.maxon.image.pix16f")
 
 MAXON_REGISTRY (ImageChannelType, ImageChannelTypes, "net.maxon.image.registry.imagechanneltypes")
 
enum maxon::BLENDPIXELFLAGS MAXON_ENUM_FLAGS (BLENDPIXELFLAGS)
 
 MAXON_DATATYPE (BlendPixelHandlerRef, "net.maxon.datatype.blendpixelhandlerref")
 
 MAXON_REGISTRY (ImagePixelBlend, ImagePixelBlends, "net.maxon.render.registry.blendmodeclasses")
 
enum maxon::CONVERTPIXELFLAGS MAXON_ENUM_FLAGS (CONVERTPIXELFLAGS)
 
enum maxon::GETPIXELHANDLERFLAGS MAXON_ENUM_FLAGS (GETPIXELHANDLERFLAGS)
 
enum maxon::GETPIXELFLAGS MAXON_ENUM_FLAGS (GETPIXELFLAGS)
 
enum maxon::SETPIXELHANDLERFLAGS MAXON_ENUM_FLAGS (SETPIXELHANDLERFLAGS)
 
enum maxon::SETPIXELFLAGS MAXON_ENUM_FLAGS (SETPIXELFLAGS)
 
Result< CONVERTPIXELFUNC > LambdaWrapper (CONVERTPIXELFUNCSTATIC func, const ChannelOffsets &dstChannelOffsets, const ChannelOffsets &srcChannelOffsets)
 
 MAXON_DECLARATION (Class< PixelFormat >, PixelFormatBaseClass, "net.maxon.image.class.pixelformatbase")
 
Result< PixelFormat > JoinPixelFormats (const PixelFormat &format1, const PixelFormat &format2)
 
 MAXON_REGISTRY (PixelFormatGroup, PixelFormats, "net.maxon.image.registry.pixelformats")
 
MAXON_ATTRIBUTE_FORCE_INLINE void ConvertPixel (Pix8u &dst, const Pix8u src)
 
MAXON_ATTRIBUTE_FORCE_INLINE void ConvertPixel (Pix8u &dst, const Pix8s src)
 
MAXON_ATTRIBUTE_FORCE_INLINE void ConvertPixel (Pix8u &dst, const Pix16u src)
 
MAXON_ATTRIBUTE_FORCE_INLINE void ConvertPixel (Pix8u &dst, const Pix16s src)
 
MAXON_ATTRIBUTE_FORCE_INLINE void ConvertPixel (Pix8u &dst, const Pix32u src)
 
MAXON_ATTRIBUTE_FORCE_INLINE void ConvertPixel (Pix8u &dst, const Pix32s src)
 
MAXON_ATTRIBUTE_FORCE_INLINE void ConvertPixel (Pix8u &dst, const Pix32f src)
 
MAXON_ATTRIBUTE_FORCE_INLINE void ConvertPixel (Pix8u &dst, const Pix64f src)
 
MAXON_ATTRIBUTE_FORCE_INLINE void ConvertPixel (Pix16u &dst, const Pix8u src)
 
MAXON_ATTRIBUTE_FORCE_INLINE void ConvertPixel (Pix16u &dst, const Pix8s src)
 
MAXON_ATTRIBUTE_FORCE_INLINE void ConvertPixel (Pix16u &dst, const Pix16u src)
 
MAXON_ATTRIBUTE_FORCE_INLINE void ConvertPixel (Pix16u &dst, const Pix16s src)
 
MAXON_ATTRIBUTE_FORCE_INLINE void ConvertPixel (Pix16u &dst, const Pix32u src)
 
MAXON_ATTRIBUTE_FORCE_INLINE void ConvertPixel (Pix16u &dst, const Pix32s src)
 
MAXON_ATTRIBUTE_FORCE_INLINE void ConvertPixel (Pix16u &dst, const Pix32f src)
 
MAXON_ATTRIBUTE_FORCE_INLINE void ConvertPixel (Pix16u &dst, const Pix64f src)
 
MAXON_ATTRIBUTE_FORCE_INLINE void ConvertPixel (Pix32u &dst, const Pix8u src)
 
MAXON_ATTRIBUTE_FORCE_INLINE void ConvertPixel (Pix32u &dst, const Pix8s src)
 
MAXON_ATTRIBUTE_FORCE_INLINE void ConvertPixel (Pix32u &dst, const Pix16u src)
 
MAXON_ATTRIBUTE_FORCE_INLINE void ConvertPixel (Pix32u &dst, const Pix16s src)
 
MAXON_ATTRIBUTE_FORCE_INLINE void ConvertPixel (Pix32u &dst, const Pix32u src)
 
MAXON_ATTRIBUTE_FORCE_INLINE void ConvertPixel (Pix32u &dst, const Pix32s src)
 
MAXON_ATTRIBUTE_FORCE_INLINE void ConvertPixel (Pix32u &dst, const Pix32f src)
 
MAXON_ATTRIBUTE_FORCE_INLINE void ConvertPixel (Pix32u &dst, const Pix64f src)
 
MAXON_ATTRIBUTE_FORCE_INLINE void ConvertPixel (Pix8s &dst, const Pix8u src)
 
MAXON_ATTRIBUTE_FORCE_INLINE void ConvertPixel (Pix8s &dst, const Pix8s src)
 
MAXON_ATTRIBUTE_FORCE_INLINE void ConvertPixel (Pix8s &dst, const Pix16u src)
 
MAXON_ATTRIBUTE_FORCE_INLINE void ConvertPixel (Pix8s &dst, const Pix16s src)
 
MAXON_ATTRIBUTE_FORCE_INLINE void ConvertPixel (Pix8s &dst, const Pix32u src)
 
MAXON_ATTRIBUTE_FORCE_INLINE void ConvertPixel (Pix8s &dst, const Pix32s src)
 
MAXON_ATTRIBUTE_FORCE_INLINE void ConvertPixel (Pix8s &dst, const Pix32f src)
 
MAXON_ATTRIBUTE_FORCE_INLINE void ConvertPixel (Pix8s &dst, const Pix64f src)
 
MAXON_ATTRIBUTE_FORCE_INLINE void ConvertPixel (Pix16s &dst, const Pix8u src)
 
MAXON_ATTRIBUTE_FORCE_INLINE void ConvertPixel (Pix16s &dst, const Pix8s src)
 
MAXON_ATTRIBUTE_FORCE_INLINE void ConvertPixel (Pix16s &dst, const Pix16u src)
 
MAXON_ATTRIBUTE_FORCE_INLINE void ConvertPixel (Pix16s &dst, const Pix16s src)
 
MAXON_ATTRIBUTE_FORCE_INLINE void ConvertPixel (Pix16s &dst, const Pix32u src)
 
MAXON_ATTRIBUTE_FORCE_INLINE void ConvertPixel (Pix16s &dst, const Pix32s src)
 
MAXON_ATTRIBUTE_FORCE_INLINE void ConvertPixel (Pix16s &dst, const Pix32f src)
 
MAXON_ATTRIBUTE_FORCE_INLINE void ConvertPixel (Pix16s &dst, const Pix64f src)
 
MAXON_ATTRIBUTE_FORCE_INLINE void ConvertPixel (Pix32s &dst, const Pix8u src)
 
MAXON_ATTRIBUTE_FORCE_INLINE void ConvertPixel (Pix32s &dst, const Pix8s src)
 
MAXON_ATTRIBUTE_FORCE_INLINE void ConvertPixel (Pix32s &dst, const Pix16u src)
 
MAXON_ATTRIBUTE_FORCE_INLINE void ConvertPixel (Pix32s &dst, const Pix16s src)
 
MAXON_ATTRIBUTE_FORCE_INLINE void ConvertPixel (Pix32s &dst, const Pix32u src)
 
MAXON_ATTRIBUTE_FORCE_INLINE void ConvertPixel (Pix32s &dst, const Pix32s src)
 
MAXON_ATTRIBUTE_FORCE_INLINE void ConvertPixel (Pix32s &dst, const Pix32f src)
 
MAXON_ATTRIBUTE_FORCE_INLINE void ConvertPixel (Pix32s &dst, const Pix64f src)
 
MAXON_ATTRIBUTE_FORCE_INLINE void ConvertPixel (Float32 &dst, const Pix8u src)
 
MAXON_ATTRIBUTE_FORCE_INLINE void ConvertPixel (Float64 &dst, const Pix8u src)
 
MAXON_ATTRIBUTE_FORCE_INLINE void ConvertPixel (Pix32f &dst, const Pix16u src)
 
MAXON_ATTRIBUTE_FORCE_INLINE void ConvertPixel (Pix32f &dst, const Pix32u src)
 
MAXON_ATTRIBUTE_FORCE_INLINE void ConvertPixel (Pix32f &dst, const Pix32s src)
 
MAXON_ATTRIBUTE_FORCE_INLINE void ConvertPixel (Pix32f &dst, const Pix32f src)
 
MAXON_ATTRIBUTE_FORCE_INLINE void ConvertPixel (Pix32f &dst, const Pix64f src)
 
MAXON_ATTRIBUTE_FORCE_INLINE void ConvertPixel (Pix64f &dst, const Pix16u src)
 
MAXON_ATTRIBUTE_FORCE_INLINE void ConvertPixel (Pix64f &dst, const Pix32u src)
 
MAXON_ATTRIBUTE_FORCE_INLINE void ConvertPixel (Pix64f &dst, const Pix32s src)
 
MAXON_ATTRIBUTE_FORCE_INLINE void ConvertPixel (Pix64f &dst, const Pix32f src)
 
MAXON_ATTRIBUTE_FORCE_INLINE void ConvertPixel (Pix64f &dst, const Pix64f src)
 
MAXON_ATTRIBUTE_FORCE_INLINE void ConvertPixel (Pix16f &dst, const Pix8u src)
 
MAXON_ATTRIBUTE_FORCE_INLINE void ConvertPixel (Pix16f &dst, const Pix16u src)
 
MAXON_ATTRIBUTE_FORCE_INLINE void ConvertPixel (Pix16f &dst, const Pix32u src)
 
MAXON_ATTRIBUTE_FORCE_INLINE void ConvertPixel (Pix16f &dst, const Pix32s src)
 
MAXON_ATTRIBUTE_FORCE_INLINE void ConvertPixel (Pix16f &dst, const Pix16f src)
 
MAXON_ATTRIBUTE_FORCE_INLINE void ConvertPixel (Pix16f &dst, const Pix32f src)
 
MAXON_ATTRIBUTE_FORCE_INLINE void ConvertPixel (Pix16f &dst, const Pix64f src)
 
template<typename PIXELDEPTH >
MAXON_ATTRIBUTE_FORCE_INLINE Bool IsPixelIdentical (PIXELDEPTH a, PIXELDEPTH b, Int oneTolerance)
 
MAXON_ATTRIBUTE_FORCE_INLINE PixelFormat GetNativeFloatColorAlphaFormat ()
 
MAXON_ATTRIBUTE_FORCE_INLINE PixelFormat GetNativeFloatColorFormat ()
 
 MAXON_REGISTRY (Class< ImagePixelStorage >, ImagePixelStorageClasses, "net.maxon.image.registry.imagepixelstorageclasses")
 
 MAXON_DATATYPE (UpdateRegion, "net.maxon.image.updateregion")
 
 MAXON_REGISTRY (Class< VectorImageRef >, VectorImageClasses, "net.maxon.image.registry.vectorimageclasses")
 
 MAXON_DECLARATION (Class< ImageRegionTilesObserverRef >, ImageRegionSingleTileObserverClass, "net.maxon.class.imageregionobserver.tiles")
 
enum maxon::LAYERSETMODE MAXON_ENUM_LIST (LAYERSETMODE)
 
 MAXON_DECLARATION (Class< MediaStreamAudioDataExportRef >, MediaStreamAudioDataExportClass, "net.maxon.image.class.mediastreamaudiodataexport")
 
template<typename REFTYPE >
static Result< Bool > MediaTraverseChildren (const REFTYPE &t, const ConstDataPtr &branch, const Delegate< Result< Bool >(const REFTYPE &child, const REFTYPE &parent, const ConstDataPtr &branch, Int depth)> &func, Int depth=0)
 
template<typename REFTYPE >
static Result< Bool > MediaTraverseMeAndChildren (const REFTYPE &t, const REFTYPE &parent, const ConstDataPtr &branch, const Delegate< Result< Bool >(const REFTYPE &child, const REFTYPE &parent, const ConstDataPtr &branch, Int depth)> &func, Int depth=0)
 
enum maxon::MEDIAFORMATTYPE MAXON_ENUM_LIST (MEDIAFORMATTYPE)
 
enum maxon::MEDIAALPHATYPE MAXON_ENUM_LIST (MEDIAALPHATYPE)
 
 MAXON_DECLARATION (Class< MediaBaseRef >, MediaBaseClass, "net.maxon.image.class.mediabase")
 
 MAXON_DECLARATION (Class< MediaConverterRef >, MediaConverterBaseClass, "net.maxon.image.class.mediaconverterbase")
 
 MAXON_DECLARATION (Class< FileFormat >, FileFormatImageBaseClass, "net.maxon.image.class.fileformatimagebase")
 
 MAXON_REGISTRY (Class< MediaOutputUrlRef >, ImageSaverClasses, "net.maxon.image.registry.imagesaverclasses")
 
enum maxon::RLACHANNELS MAXON_ENUM_LIST (RLACHANNELS)
 
enum maxon::RLAFLAGS MAXON_ENUM_FLAGS (RLAFLAGS)
 
Char GetRlaRpfChannelSymbol (RLACHANNELS channel)
 
Int GetRlaRpfChannelSize (RLACHANNELS channel)
 
Tuple< ImageChannel, ImageChannel, ImageChannel > GetRlaRpfChannelType (RLACHANNELS channel)
 
Int64 ToWindowsTime (const TimeValue &time)
 
TimeValue ToMaxonTime (Int64 time)
 
Vec2< Int > FpsToInt (Float fps)
 
enum maxon::SELECTIONHANDLERRESULT MAXON_ENUM_FLAGS (SELECTIONHANDLERRESULT)
 
 MAXON_DECLARATION (Class< MediaOutputRef >, MediaOutputBaseClass, "net.maxon.image.class.mediaoutputbase")
 
 MAXON_DECLARATION (Class< MediaOutputTextureRef >, MediaOutputTextureClass, "net.maxon.image.class.mediaoutputtexture")
 
 MAXON_DECLARATION (Class< MediaOutputUrlRef >, MediaOutputUrlBaseClass, "net.maxon.image.class.mediaoutputurlbase")
 
Result< MediaSessionRef > MediaSessionImport (const Url &fileName, const TimeValue &targetTime, MEDIASESSIONFLAGS flags, const MediaOutputRef &outputConverter, const MediaOutputSelectionHandler &selectionHandler, const MediaSessionProgressCallback &progressCallback, const FileFormatHandler &preferredHandler, const ValueReceiver< const FileFormatHandler & > &fileFormats={})
 
enum maxon::MEDIASESSIONFLAGS MAXON_ENUM_FLAGS (MEDIASESSIONFLAGS)
 
 MAXON_DECLARATION (Class< MediaSessionRef >, MediaSessionObject, "net.maxon.image.class.mediasessionobject")
 
 MAXON_DECLARATION (Class< MediaStreamRef >, MediaStreamBaseClass, "net.maxon.image.class.mediastreambase")
 
 MAXON_DECLARATION (Class< MediaStreamExifDataRef >, MediaStreamExifDataClass, "net.maxon.image.class.mediastreamexifdata")
 
 MAXON_DECLARATION (Class< MediaStreamImageBaseRef >, MediaStreamImageBaseClass, "net.maxon.image.class.mediastreamimagebase")
 
 MAXON_DECLARATION (Class< MediaStreamImageDataImportRef >, MediaStreamImageDataImportClass, "net.maxon.image.class.mediastreamimagedataimport")
 
 MAXON_DECLARATION (Class< MediaStreamImageDataExportRef >, MediaStreamImageDataExportClass, "net.maxon.image.class.mediastreamimagedataexport")
 
 MAXON_DECLARATION (Class< MediaStreamAudioDataImportRef >, MediaStreamAudioDataImportClass, "net.maxon.image.class.mediastreamaudiodataimport")
 
 MAXON_DECLARATION (Class< MediaStreamImageDataForwardImportRef >, MediaStreamForwardImageDataStreamsImportClass, "net.maxon.image.class.mediastreamforwardimagedatastreamsimport")
 
Result< Data > GetSelectedFormatPreferAspectRatio_1_1 (const MediaStreamRef &stream, MediaStreamFormat &resFormat)
 
 MAXON_DECLARATION (Class< MediaStreamFormat >, MediaStreamFormatClass, "net.maxon.image.class.mediastreamformat")
 
 MAXON_DECLARATION (Class< MediaStreamProperties >, MediaStreamPropertiesClass, "net.maxon.image.class.mediastreamproperties")
 
template<typename FLOATTYPE >
MAXON_ATTRIBUTE_FORCE_INLINE FLOATTYPE BlendOver (FLOATTYPE background, FLOATTYPE foreground)
 
template<typename FLOATTYPE >
MAXON_ATTRIBUTE_FORCE_INLINE FLOATTYPE BlendAverage (FLOATTYPE background, FLOATTYPE foreground)
 
template<typename FLOATTYPE >
MAXON_ATTRIBUTE_FORCE_INLINE FLOATTYPE BlendMultiply (FLOATTYPE background, FLOATTYPE foreground)
 
template<typename FLOATTYPE >
MAXON_ATTRIBUTE_FORCE_INLINE FLOATTYPE BlendScreen (FLOATTYPE background, FLOATTYPE foreground)
 
template<typename FLOATTYPE >
MAXON_ATTRIBUTE_FORCE_INLINE FLOATTYPE BlendSubtract (FLOATTYPE background, FLOATTYPE foreground)
 
template<typename FLOATTYPE >
MAXON_ATTRIBUTE_FORCE_INLINE FLOATTYPE BlendDivide (FLOATTYPE background, FLOATTYPE foreground)
 
template<typename FLOATTYPE >
MAXON_ATTRIBUTE_FORCE_INLINE FLOATTYPE BlendAdd (FLOATTYPE background, FLOATTYPE foreground)
 
template<typename FLOATTYPE >
MAXON_ATTRIBUTE_FORCE_INLINE FLOATTYPE BlendOverlay (FLOATTYPE background, FLOATTYPE foreground)
 
template<typename FLOATTYPE >
MAXON_ATTRIBUTE_FORCE_INLINE FLOATTYPE BlendHardLight (FLOATTYPE background, FLOATTYPE foreground)
 
template<typename FLOATTYPE >
MAXON_ATTRIBUTE_FORCE_INLINE FLOATTYPE BlendSoftLight (FLOATTYPE background, FLOATTYPE foreground)
 
template<typename FLOATTYPE >
MAXON_ATTRIBUTE_FORCE_INLINE FLOATTYPE BlendDarken (FLOATTYPE background, FLOATTYPE foreground)
 
template<typename FLOATTYPE >
MAXON_ATTRIBUTE_FORCE_INLINE FLOATTYPE BlendLighten (FLOATTYPE background, FLOATTYPE foreground)
 
template<typename FLOATTYPE >
MAXON_ATTRIBUTE_FORCE_INLINE FLOATTYPE BlendPinLight (FLOATTYPE background, FLOATTYPE foreground)
 
template<typename FLOATTYPE >
MAXON_ATTRIBUTE_FORCE_INLINE FLOATTYPE BlendDifference (FLOATTYPE background, FLOATTYPE foreground)
 
template<typename FLOATTYPE >
MAXON_ATTRIBUTE_FORCE_INLINE FLOATTYPE BlendExclusion (FLOATTYPE background, FLOATTYPE foreground)
 
template<typename FLOATTYPE >
MAXON_ATTRIBUTE_FORCE_INLINE FLOATTYPE BlendNegative (FLOATTYPE background, FLOATTYPE foreground)
 
template<typename FLOATTYPE >
MAXON_ATTRIBUTE_FORCE_INLINE FLOATTYPE BlendStamp (FLOATTYPE background, FLOATTYPE foreground)
 
template<typename FLOATTYPE >
MAXON_ATTRIBUTE_FORCE_INLINE FLOATTYPE BlendXor (FLOATTYPE background, FLOATTYPE foreground)
 
template<typename FLOATTYPE >
MAXON_ATTRIBUTE_FORCE_INLINE FLOATTYPE BlendGlow (FLOATTYPE background, FLOATTYPE foreground)
 
template<typename FLOATTYPE >
MAXON_ATTRIBUTE_FORCE_INLINE FLOATTYPE BlendReflect (FLOATTYPE background, FLOATTYPE foreground)
 
template<typename FLOATTYPE >
MAXON_ATTRIBUTE_FORCE_INLINE FLOATTYPE BlendHeat (FLOATTYPE background, FLOATTYPE foreground)
 
template<typename FLOATTYPE >
MAXON_ATTRIBUTE_FORCE_INLINE FLOATTYPE BlendFreeze (FLOATTYPE background, FLOATTYPE foreground)
 
template<typename FLOATTYPE >
MAXON_ATTRIBUTE_FORCE_INLINE FLOATTYPE BlendHypot (FLOATTYPE background, FLOATTYPE foreground)
 
template<typename FLOATTYPE >
MAXON_ATTRIBUTE_FORCE_INLINE FLOATTYPE Dissolve (FLOATTYPE background, FLOATTYPE foreground)
 
template<typename FLOATTYPE >
MAXON_ATTRIBUTE_FORCE_INLINE FLOATTYPE BlendHardMix (FLOATTYPE background, FLOATTYPE foreground)
 
template<typename FLOATTYPE >
MAXON_ATTRIBUTE_FORCE_INLINE FLOATTYPE BlendColorDodge (FLOATTYPE background, FLOATTYPE foreground)
 
template<typename FLOATTYPE >
MAXON_ATTRIBUTE_FORCE_INLINE FLOATTYPE BlendColorBurn (FLOATTYPE background, FLOATTYPE foreground)
 
template<typename FLOATTYPE >
MAXON_ATTRIBUTE_FORCE_INLINE FLOATTYPE BlendLinearDodge (FLOATTYPE background, FLOATTYPE foreground)
 
template<typename FLOATTYPE >
MAXON_ATTRIBUTE_FORCE_INLINE FLOATTYPE BlendLinearBurn (FLOATTYPE background, FLOATTYPE foreground)
 
template<typename FLOATTYPE >
MAXON_ATTRIBUTE_FORCE_INLINE FLOATTYPE BlendVividLight (FLOATTYPE background, FLOATTYPE foreground)
 
template<typename COLORTYPE >
MAXON_ATTRIBUTE_FORCE_INLINE COLORTYPE BlendHue (const COLORTYPE &background, const COLORTYPE &foreground)
 
template<typename COLORTYPE >
MAXON_ATTRIBUTE_FORCE_INLINE COLORTYPE BlendSaturation (const COLORTYPE &background, const COLORTYPE &foreground)
 
template<typename COLORTYPE >
MAXON_ATTRIBUTE_FORCE_INLINE COLORTYPE BlendLuminance (const COLORTYPE &background, const COLORTYPE &foreground)
 
template<typename COLORTYPE >
MAXON_ATTRIBUTE_FORCE_INLINE COLORTYPE BlendColor (const COLORTYPE &background, const COLORTYPE &foreground)
 
template<typename COLORTYPE >
MAXON_ATTRIBUTE_FORCE_INLINE COLORTYPE BlendLevr (const COLORTYPE &background, const COLORTYPE &foreground)
 
template<typename COLORTYPE >
static MAXON_ATTRIBUTE_FORCE_INLINE COLORTYPE::ValueType LuminanceColor (const COLORTYPE &color)
 
template<typename COLORATYPE >
static MAXON_ATTRIBUTE_FORCE_INLINE COLORATYPE::ValueType LuminanceColorA (const COLORATYPE &color)
 
template<typename COLORTYPE >
MAXON_ATTRIBUTE_FORCE_INLINE COLORTYPE BlendDarker (const COLORTYPE &background, const COLORTYPE &foreground)
 
template<typename COLORTYPE >
MAXON_ATTRIBUTE_FORCE_INLINE COLORTYPE BlendLighter (const COLORTYPE &background, const COLORTYPE &foreground)
 
enum maxon::BLEND_MODES MAXON_ENUM_LIST (BLEND_MODES)
 
template<BLEND_MODES MODE, typename COLORATYPE >
static MAXON_ATTRIBUTE_FORCE_INLINE COLORATYPE BlendRGBA (const COLORATYPE &background, const COLORATYPE &foreground, typename COLORATYPE::ValueType opacity)
 
MAXON_ATTRIBUTE_FORCE_INLINE Color XyzToRgb (const Color &xyz)
 
MAXON_ATTRIBUTE_FORCE_INLINE Color RgbToXyz (const Color &rgb)
 
MAXON_ATTRIBUTE_FORCE_INLINE Color RgbToCmy (const Color rgb)
 
MAXON_ATTRIBUTE_FORCE_INLINE Color CmyToRgb (const Color cmy)
 
template<typename COLORTYPE >
MAXON_ATTRIBUTE_FORCE_INLINE COLORTYPE RgbToHsv (const COLORTYPE &rgb)
 
template<typename COLORTYPE >
MAXON_ATTRIBUTE_FORCE_INLINE COLORTYPE HsvToRgb (const COLORTYPE &hsv)
 
template<typename COLORTYPE >
MAXON_ATTRIBUTE_FORCE_INLINE COLORTYPE RgbToHsl (const COLORTYPE &rgb)
 
template<typename FLOATTYPE >
MAXON_ATTRIBUTE_FORCE_INLINE FLOATTYPE Value (FLOATTYPE nl, FLOATTYPE n2, FLOATTYPE hue)
 
template<typename COLORTYPE >
MAXON_ATTRIBUTE_FORCE_INLINE COLORTYPE HslToRgb (const COLORTYPE &hsl)
 
MAXON_ATTRIBUTE_FORCE_INLINE Color ColorTemperatureToRGB (Float temperature)
 
template<typename T >
MAXON_ATTRIBUTE_FORCE_INLINE enable_if_float< T > Fract (T value)
 
template<typename T >
MAXON_ATTRIBUTE_FORCE_INLINE enable_if_float< T > Invert (T value)
 
template<typename T >
MAXON_ATTRIBUTE_FORCE_INLINE enable_if_scalar< T > ClampValueCustom (T value, T lowerLimit, T upperLimit)
 
template<typename T >
MAXON_ATTRIBUTE_FORCE_INLINE enable_if_scalar< T > MinCustom (T a, T b)
 
template<typename T >
MAXON_ATTRIBUTE_FORCE_INLINE enable_if_scalar< T > MaxCustom (T a, T b)
 
template<typename T >
MAXON_ATTRIBUTE_FORCE_INLINE enable_if_scalar< T > SignNoTemplate (T value)
 
template<typename T >
MAXON_ATTRIBUTE_FORCE_INLINE enable_if_integral< T > FMod (T a, T b)
 
template<typename T >
MAXON_ATTRIBUTE_FORCE_INLINE enable_if_scalar< T > MapRange (T input, T inputMin, T inputMax, T outputMin, T outputMax)
 
template<typename T >
MAXON_ATTRIBUTE_FORCE_INLINE enable_if_float< T > Step (T value, T threshold)
 
template<typename T >
MAXON_ATTRIBUTE_FORCE_INLINE enable_if_float< T > Quantize (T value, T steps)
 
template<typename T >
MAXON_ATTRIBUTE_FORCE_INLINE enable_if_float< T > Cbrt (T input)
 
MAXON_ATTRIBUTE_FORCE_INLINE Float32 SquaredLength (const Vector2d32 &input)
 
MAXON_ATTRIBUTE_FORCE_INLINE Float64 SquaredLength (const Vector2d64 &input)
 
MAXON_ATTRIBUTE_FORCE_INLINE Float32 SquaredLength (const Vector32 &input)
 
MAXON_ATTRIBUTE_FORCE_INLINE Float64 SquaredLength (const Vector64 &input)
 
MAXON_ATTRIBUTE_FORCE_INLINE Float32 SquaredLength (const Vector4d32 &input)
 
MAXON_ATTRIBUTE_FORCE_INLINE Float64 SquaredLength (const Vector4d64 &input)
 
MAXON_ATTRIBUTE_FORCE_INLINE Float32 SquaredLength (const Color32 &input)
 
MAXON_ATTRIBUTE_FORCE_INLINE Float64 SquaredLength (const Color64 &input)
 
MAXON_ATTRIBUTE_FORCE_INLINE Float32 SquaredLength (const ColorA32 &input)
 
MAXON_ATTRIBUTE_FORCE_INLINE Float64 SquaredLength (const ColorA64 &input)
 
MAXON_ATTRIBUTE_FORCE_INLINE Float32 Length (const Vector2d32 &input)
 
MAXON_ATTRIBUTE_FORCE_INLINE Float64 Length (const Vector2d64 &input)
 
MAXON_ATTRIBUTE_FORCE_INLINE Float32 Length (const Vector32 &input)
 
MAXON_ATTRIBUTE_FORCE_INLINE Float64 Length (const Vector64 &input)
 
MAXON_ATTRIBUTE_FORCE_INLINE Float32 Length (const Vector4d32 &input)
 
MAXON_ATTRIBUTE_FORCE_INLINE Float64 Length (const Vector4d64 &input)
 
MAXON_ATTRIBUTE_FORCE_INLINE Float32 Length (const Color32 &input)
 
MAXON_ATTRIBUTE_FORCE_INLINE Float64 Length (const Color64 &input)
 
MAXON_ATTRIBUTE_FORCE_INLINE Float32 Length (const ColorA32 &input)
 
MAXON_ATTRIBUTE_FORCE_INLINE Float64 Length (const ColorA64 &input)
 
MAXON_ATTRIBUTE_FORCE_INLINE Float64 SafePow (Float64 v1, Float64 v2)
 
MAXON_ATTRIBUTE_FORCE_INLINE Float32 SafePow (Float32 v1, Float32 v2)
 
MAXON_ATTRIBUTE_FORCE_INLINE Float64 SafeSqrt (Float64 v)
 
MAXON_ATTRIBUTE_FORCE_INLINE Float32 SafeSqrt (Float32 v)
 
 MATH_HELPER_INSTANTIATE (Clamp01)
 
 MATH_HELPER_INSTANTIATE (ATan2)
 
 MATH_HELPER_INSTANTIATE (Exp)
 
 MATH_HELPER_INSTANTIATE (Exp2)
 
 MATH_HELPER_INSTANTIATE (Ln)
 
 MATH_HELPER_INSTANTIATE (Log10)
 
 MATH_HELPER_INSTANTIATE (Log2)
 
 MATH_HELPER_INSTANTIATE (Gamma)
 
 MATH_HELPER_INSTANTIATE (Si)
 
 MATH_HELPER_INSTANTIATE (Sinc)
 
 MATH_HELPER_INSTANTIATE (Abs)
 
 MATH_HELPER_INSTANTIATE (Ceil)
 
 MATH_HELPER_INSTANTIATE (Floor)
 
 MATH_HELPER_INSTANTIATE (Round)
 
 MATH_HELPER_INSTANTIATE (ClampValueCustom)
 
 MATH_HELPER_INSTANTIATE (MinCustom)
 
 MATH_HELPER_INSTANTIATE (MaxCustom)
 
 MATH_HELPER_INSTANTIATE (Fract)
 
 MATH_HELPER_INSTANTIATE (Invert)
 
 MATH_HELPER_INSTANTIATE (FMod)
 
 MATH_HELPER_INSTANTIATE (MapRange)
 
 MATH_HELPER_INSTANTIATE (Inverse)
 
 MATH_HELPER_INSTANTIATE (SignNoTemplate)
 
 MATH_HELPER_INSTANTIATE (SmoothStep)
 
 MATH_HELPER_INSTANTIATE (BoxStep)
 
 MATH_HELPER_INSTANTIATE (Step)
 
 MATH_HELPER_INSTANTIATE (Quantize)
 
 MATH_HELPER_INSTANTIATE (Pow)
 
 MATH_HELPER_INSTANTIATE (Sqrt)
 
 MATH_HELPER_INSTANTIATE (Cbrt)
 
 MATH_HELPER_INSTANTIATE (Sin)
 
 MATH_HELPER_INSTANTIATE (Cos)
 
 MATH_HELPER_INSTANTIATE (Tan)
 
 MATH_HELPER_INSTANTIATE (Sinh)
 
 MATH_HELPER_INSTANTIATE (Cosh)
 
 MATH_HELPER_INSTANTIATE (Tanh)
 
 MATH_HELPER_INSTANTIATE (ASin)
 
 MATH_HELPER_INSTANTIATE (ACos)
 
 MATH_HELPER_INSTANTIATE (ATan)
 
 MATH_HELPER_INSTANTIATE (SafePow)
 
 MATH_HELPER_INSTANTIATE (SafeSqrt)
 
enum maxon::ANIMBLENDSTATE MAXON_ENUM_LIST (ANIMBLENDSTATE)
 
 MAXON_DECLARATION (Class< BlendAnimationRef >, AnimBlendClass, "net.maxon.class.blendanimationref")
 
 MAXON_REGISTRY (BlendFunctionRef, BlendFunctions, "net.maxon.registry.blendfunction")
 
template<typename T >
static T ComplexGetReal (const Complex< T > &val)
 
template<typename T >
static T ComplexGetReal (const T &val)
 
template<typename T >
static T ComplexGetImag (const Complex< T > &val)
 
template<typename T >
static T ComplexGetImag (const T &val)
 
template<typename T1 , typename T2 >
static void ComplexSetReal (Complex< T1 > &dst, const T2 &val)
 
template<typename T1 , typename T2 >
static void ComplexSetReal (T1 &dst, const T2 &val)
 
template<typename T1 , typename T2 >
static void ComplexSetImag (Complex< T1 > &dst, const T2 &val)
 
template<typename T1 , typename T2 >
static void ComplexSetImag (T1 &dst, const T2 &val)
 
 MAXON_DATATYPE (Complex32, "net.maxon.datatype.complex32")
 
 MAXON_DATATYPE (Complex64, "net.maxon.datatype.complex64")
 
enum maxon::FFT_FLAGS MAXON_ENUM_FLAGS (FFT_FLAGS)
 
enum maxon::FFT_SUPPORT MAXON_ENUM_FLAGS (FFT_SUPPORT)
 
 MAXON_REGISTRY (Class< FFTRef >, FFTClasses, "net.maxon.registry.fftclasses")
 
enum maxon::GRADIENT_INTERPOLATION_TYPE MAXON_ENUM_ORDERED_LIST (GRADIENT_INTERPOLATION_TYPE)
 
COMPARERESULT Compare (const GradientKnot &a, const GradientKnot &b)
 
 MAXON_DATATYPE (MatrixNxM32, "net.maxon.datatype.matrixnxm32")
 
 MAXON_DATATYPE (MatrixNxM64, "net.maxon.datatype.matrixnxm64")
 
 MAXON_DATATYPE (MatrixNxMComplex32, "net.maxon.datatype.matrixnxmcomplex32")
 
 MAXON_DATATYPE (MatrixNxMComplex64, "net.maxon.datatype.matrixnxmcomplex64")
 
ROTATIONORDER TranslateRotationOrder (const Id &type)
 
 MAXON_DATATYPE (PRSMatrix64, "net.maxon.neutron.datatype.psrmatrix")
 
 MAXON_DATATYPE (PRSMatrix32, "net.maxon.math.datatype.prsmatrix32")
 
 MAXON_REGISTRY (Class< RenderNoiseRef >, RenderNoiseClasses, "net.maxon.render.registry.rendernoiseclasses")
 
enum maxon::NURBSCURVE_CONTINUITY MAXON_ENUM_LIST (NURBSCURVE_CONTINUITY)
 
template<Int D>
 MAXON_IMPLEMENTATION_SIMPLE_REGISTER (NURBSCurveWithContinuity< D >)
 
enum maxon::NURBSCURVE_KNOTMODE MAXON_ENUM_LIST (NURBSCURVE_KNOTMODE)
 
template<Int D>
 MAXON_IMPLEMENTATION_SIMPLE_REGISTER (NURBSCurve< D >)
 
 MAXON_DATATYPE (Quaternion32, "net.maxon.datatype.quaternion32")
 
 MAXON_DATATYPE (Quaternion64, "net.maxon.datatype.quaternion64")
 
enum maxon::SPLINEMAPPER_KNOT_INTERPOLATION_TYPE MAXON_ENUM_ORDERED_LIST (SPLINEMAPPER_KNOT_INTERPOLATION_TYPE)
 
enum maxon::SPLINEMAPPER_KNOT_FLAGS Int MAXON_ENUM_FLAGS (SPLINEMAPPER_KNOT_FLAGS)
 
 MAXON_DATATYPE (SplineMapperKnot, "net.maxon.datatype.splinemapperknot")
 
enum maxon::SPLINEMAPPER_SPLINE_TYPE MAXON_ENUM_ORDERED_LIST (SPLINEMAPPER_SPLINE_TYPE)
 
enum maxon::SPLINEMAPPER_RANGE_STATE MAXON_ENUM_ORDERED_LIST (SPLINEMAPPER_RANGE_STATE)
 
void MatrixConvert (SquareMatrix4d &dest, const Matrix &src)
 
enum maxon::PRIMITIVETYPE MAXON_ENUM_LIST (PRIMITIVETYPE)
 
 MAXON_DECLARATION (Class< DistanceQueryRef >, DistanceCalculator, "net.maxon.geom.interface.distancequery.distancecalculator")
 
 MAXON_REGISTRY (CustomDataTagClass, CustomDataTagClasses, "net.maxon.mesh_misc.registry.customdatatagclasses")
 
 MAXON_REGISTRY (Class< CustomDataTagDisplayRef >, CustomDataTagDisplayClasses, "net.maxon.mesh_misc.registry.customdatatagdisplayclasses")
 
 MAXON_DATATYPE (MeshAttribute, "net.maxon.mesh_misc.datatype.meshattribute")
 
 MAXON_DATATYPE (PolygroupInformation, "net.maxon.meshattribute.gozpolyinformation")
 
 MAXON_MESHATTRIBUTE (PolygroupInformation, POLYGROUP)
 
 MAXON_DATATYPE (POLYGROUP_MESHATTRIBUTE, "net.maxon.meshattribute.gozpolygroup")
 
 MAXON_DECLARATION (Class< VoxelizationRef >, PolyVoxelization, "net.maxon.geom.interface.voxelization.polyvoxelization")
 
enum maxon::METRICUNIT MAXON_ENUM_LIST (METRICUNIT)
 
enum maxon::ANGLEUNIT MAXON_ENUM_LIST (ANGLEUNIT)
 
enum maxon::CORENODE_PORT_FLAGS MAXON_ENUM_FLAGS (CORENODE_PORT_FLAGS)
 
enum maxon::PORT_DIR Int MAXON_ENUM_LIST (PORT_DIR)
 
PORT_DIR & operator++ (PORT_DIR &dir)
 
PORT_DIR Reverse (PORT_DIR dir)
 
 MAXON_REGISTRY (IconProvider, IconProviders, "net.maxon.registry.iconproviders")
 
Result< Url > GetUrlFromIconProviders (const CString &iconId)
 
enum maxon::IOFORMAT MAXON_ENUM_LIST (IOFORMAT)
 
template<typename T >
std::enable_if< GetCollectionKind< T >::value==COLLECTION_KIND::ARRAY, Result< void > >::type ReadDocument (const Url &url, const Id &id, T &object, const DataDictionary &dict=DataDictionary())
 
template<typename T >
std::enable_if< GetCollectionKind< T >::value !=COLLECTION_KIND::ARRAY &&!STD_IS_REPLACEMENT(same, T, Data), Result< void > >::type ReadDocument (const Url &url, const Id &id, T &object, const DataDictionary &dict=DataDictionary())
 
template<typename T >
std::enable_if< STD_IS_REPLACEMENT(same, T, Data), Result< void > >::type ReadDocument (const Url &url, const Id &id, T &object, const DataDictionary &dict=DataDictionary())
 
template<typename T >
std::enable_if< GetCollectionKind< T >::value==COLLECTION_KIND::ARRAY, Result< void > >::type ReadDocument (UrlOrInputStream &&urlOrStream, const Id &id, T &object, IOFORMAT format=IOFORMAT::DEFAULT, const DataDictionary &dict=DataDictionary())
 
template<typename T >
std::enable_if< GetCollectionKind< T >::value !=COLLECTION_KIND::ARRAY &&!STD_IS_REPLACEMENT(same, T, Data), Result< void > >::type ReadDocument (UrlOrInputStream &&urlOrStream, const Id &id, T &object, IOFORMAT format=IOFORMAT::DEFAULT, const DataDictionary &dict=DataDictionary())
 
template<typename T >
std::enable_if< STD_IS_REPLACEMENT(same, T, Data), Result< void > >::type ReadDocument (UrlOrInputStream &&urlOrStream, const Id &id, T &object, IOFORMAT format=IOFORMAT::DEFAULT, const DataDictionary &dict=DataDictionary())
 
template<typename T >
Result< void > WriteDocument (const Url &url, OPENSTREAMFLAGS flags, const Id &id, const T &object, IOFORMAT format=IOFORMAT::DEFAULT, const DataDictionary &dict=DataDictionary())
 
template<typename T >
std::enable_if< GetCollectionKind< T >::value==COLLECTION_KIND::ARRAY, Result< void > >::type WriteDocument (const OutputStreamRef &stream, const Id &id, const T &object, IOFORMAT format=IOFORMAT::DEFAULT, const DataDictionary &dict=DataDictionary())
 
template<typename T >
std::enable_if< STD_IS_REPLACEMENT(same, T, Data), Result< void > >::type WriteDocument (const OutputStreamRef &stream, const Id &id, const T &object, IOFORMAT format=IOFORMAT::DEFAULT, const DataDictionary &dict=DataDictionary())
 
template<typename T >
std::enable_if< GetCollectionKind< T >::value !=COLLECTION_KIND::ARRAY &&!STD_IS_REPLACEMENT(same, T, Data), Result< void > >::type WriteDocument (const OutputStreamRef &stream, const Id &id, const T &object, IOFORMAT format=IOFORMAT::DEFAULT, const DataDictionary &dict=DataDictionary())
 
enum maxon::PROFILER_POINT_TYPE MAXON_ENUM_LIST (PROFILER_POINT_TYPE)
 
enum maxon::PROFILER_STATE MAXON_ENUM_LIST (PROFILER_STATE)
 
enum maxon::PROFILER_CLOCK_MODE MAXON_ENUM_LIST (PROFILER_CLOCK_MODE)
 
 MAXON_DECLARATION (maxon::Profiler *, ProfilerInstance, "net.maxon.profiler")
 
enum maxon::SELECTION_MODE UChar MAXON_ENUM_LIST (SELECTION_MODE)
 
enum maxon::SELECTION_STATUS UChar MAXON_ENUM_FLAGS (SELECTION_STATUS)
 
 MAXON_DATATYPE (SourceControlChangeEntry, "net.maxon.sourcecontrolchangeentry")
 
Result< void > SCCCheckOutFile (const Url &url, Bool outputError)
 
Result< void > SCCAddFile (const Url &url, Bool outputError)
 
 MAXON_REGISTRY (Class< SqlDatabaseRef >, SqlDatabaseClasses, "net.maxon.registry.sqldatabaseclasses")
 
enum maxon::REGPARSEMODE MAXON_ENUM_LIST (REGPARSEMODE)
 
 MAXON_REGISTRY (SubData, SubDatas, "net.maxon.registry.subdatas")
 
 MAXON_REGISTRY (SubDataOperation, SubDataOperations, "net.maxon.registry.subdataoperations")
 
 MAXON_REGISTRY (Class< UnitTestRef >, UnitTestClasses, "net.maxon.registry.unittestclasses")
 
 MAXON_REGISTRY (Class< UnitTestRef >, UnitTestWithC4DPluginClasses, "net.maxon.registry.unittestwithc4dpluginclasses")
 
 MAXON_REGISTRY (Class< UnitTestRef >, SpeedTestClasses, "net.maxon.registry.speedtestclasses")
 
 MAXON_REGISTRY (Class< UnitTestRef >, LongRunTestClasses, "net.maxon.registry.longruntestclasses")
 
 MAXON_DECLARATION (Class< UnitTestRef >, UnitTestBaseClass, "net.maxon.class.unittestbase")
 
enum maxon::HTTPCODE MAXON_ENUM_LIST (HTTPCODE)
 
enum maxon::SOCKETMODE MAXON_ENUM_LIST (SOCKETMODE)
 
enum maxon::CONNECTIONMODE MAXON_ENUM_LIST (CONNECTIONMODE)
 
enum maxon::CONNECTIONTYPE MAXON_ENUM_LIST (CONNECTIONTYPE)
 
 MAXON_DECLARATION_STRINGENCODING ("html", Html)
 
 MAXON_DECLARATION_STRINGENCODING ("punycode", Punycode)
 
enum maxon::PROTOCOL MAXON_ENUM_LIST (PROTOCOL)
 
enum maxon::WILDCARD_IPV4_ADDRESS_TYPE MAXON_ENUM_LIST (WILDCARD_IPV4_ADDRESS_TYPE)
 
enum maxon::WILDCARD_IPV6_ADDRESS_TYPE MAXON_ENUM_LIST (WILDCARD_IPV6_ADDRESS_TYPE)
 
 MAXON_DECLARATION (Class< SSHNetworkConnectionRef >, NetworkConnectionSSHClass, "net.maxon.class.networkconnectionssh")
 
enum maxon::SSLSOCKETTYPE MAXON_ENUM_LIST (SSLSOCKETTYPE)
 
enum maxon::SSLPROTOCOLVERSION MAXON_ENUM_LIST (SSLPROTOCOLVERSION)
 
enum maxon::SSLCERTREQUIREMENTS MAXON_ENUM_FLAGS (SSLCERTREQUIREMENTS)
 
enum maxon::SSLFILETYPE MAXON_ENUM_LIST (SSLFILETYPE)
 
 MAXON_DECLARATION (Class< SSLNetworkConnectionRef >, NetworkConnectionSSLClass, "net.maxon.class.networkconnectionssl")
 
enum maxon::OAUTHSIGNATUREMETHOD MAXON_ENUM_LIST (OAUTHSIGNATUREMETHOD)
 
enum maxon::OAUTHHTTPMETHOD MAXON_ENUM_LIST (OAUTHHTTPMETHOD)
 
enum maxon::OAUTHERRORCODE MAXON_ENUM_LIST (OAUTHERRORCODE)
 
 MAXON_DECLARATION (Class< UrlRedirectRef >, UrlRedirectClass, "net.maxon.class.urlredirectclass")
 
Bool operator== (const ResourceIdentifier &lhs, const ResourceIdentifier &rhs)
 
Bool operator!= (const ResourceIdentifier &lhs, const ResourceIdentifier &rhs)
 
Bool operator== (const ServiceProviderDetails &lhs, const ServiceProviderDetails &rhs)
 
Bool operator!= (const ServiceProviderDetails &lhs, const ServiceProviderDetails &rhs)
 
enum maxon::MEDIA MAXON_ENUM_LIST (MEDIA)
 
enum maxon::MEDIASUB MAXON_ENUM_LIST (MEDIASUB)
 
enum maxon::SMTPRECEIVERFIELD UChar MAXON_ENUM_LIST (SMTPRECEIVERFIELD)
 
enum maxon::HTTPMETHOD MAXON_ENUM_LIST (HTTPMETHOD)
 
CString ConvertFromUnicodeToUtf8Url (const StringEncodingRef &urlEncoding, const String &src)
 
 MAXON_DECLARATION (ComponentDescriptor, CombinerHttpCodeComponents, "net.maxon.component.combinerhttpcodecomponents")
 
enum maxon::HTTPREQUESTTYPE MAXON_ENUM_LIST (HTTPREQUESTTYPE)
 
 MAXON_DECLARATION (Class< NetworkIpHandlerRef >, NetworkIpHandlerClass, "net.maxon.class.networkiphandler")
 
 MAXON_DECLARATION (Class< NetworkHttpHandlerRef >, NetworkHttpHandlerClass, "net.maxon.class.networkhttphandler")
 
 MAXON_DECLARATION (Class< NetworkWebServerRef >, NetworkWebServerClass, "net.maxon.class.networkwebserver")
 
enum maxon::WEBSOCKETSTATE MAXON_ENUM_LIST (WEBSOCKETSTATE)
 
enum maxon::WEBSOCKETTYPE MAXON_ENUM_LIST (WEBSOCKETTYPE)
 
enum maxon::WEBSOCKET_OPCODE UChar MAXON_ENUM_LIST (WEBSOCKET_OPCODE)
 
 MAXON_DECLARATION (Class< NetworkWebSocketConnectionRef >, NetworkWebSocketConnectionClass, "net.maxon.class.networkwebsocketconnection")
 
 MAXON_DECLARATION (Class< NetworkWebSocketSignalRef >, NetworkWebSocketSignalClass, "net.maxon.class.networkwebsocketsignal")
 
 MAXON_DECLARATION (Class< NetworkWebSocketServerRef >, NetworkWebSocketServerClass, "net.maxon.class.networkwebsocketserver")
 
 MAXON_DECLARATION (Class< NetworkWebSocketClientConnectionRef >, NetworkWebSocketClientConnectionClass, "net.maxon.class.networkwebsocketclientconnection")
 
enum maxon::ZEROCONFACTION MAXON_ENUM_FLAGS (ZEROCONFACTION)
 
enum maxon::ZEROCONFMACHINESTATE MAXON_ENUM_LIST (ZEROCONFMACHINESTATE)
 
enum maxon::ZEROCONFERROR MAXON_ENUM_LIST (ZEROCONFERROR)
 
 MAXON_INTERNED_ID ("in", DefaultInIoNode)
 
 MAXON_INTERNED_ID ("out", DefaultOutIoNode)
 
 MAXON_ATTRIBUTE (void, AssetCategoryNodeContext, "net.maxon.asset.category.nodecontext")
 
enum maxon::NIMBUS_PATH MAXON_ENUM_LIST (NIMBUS_PATH)
 
 MAXON_DATATYPE (WeakNimbusBaseRef, "net.maxon.datatype.weaknimbusref")
 
 MAXON_REGISTRY (Class< CodeExchangeRef >, CodeExchanges, "net.maxon.registry.codeexchange")
 
 MAXON_REGISTRY (Class< CodeExchangeRef >, CodeExchangesEnabled, "net.maxon.registry.codeexchange_enabled")
 
enum maxon::PyStringEncodings MAXON_ENUM_LIST (PyStringEncodings)
 
enum maxon::OWNERSHIP MAXON_ENUM_LIST (OWNERSHIP)
 
MAXON_ATTRIBUTE_FORCE_INLINE ErrorStorage operator/ (const FunctionRegistration &reg, py::NativePyCFunctionWithKeywords func)
 
 MAXON_REGISTRY (Class< PyModuleRef >, PyModules, "net.maxon.python.registry.pymodules")
 
 MAXON_REGISTRY (Class< LibraryRef >, CPythonLibs, "net.maxon.python.registry.cpythonlibs")
 
py::CPythonLibraryRef PrivateExtractCPythonLibrary3 (py::NativePyObject *self)
 
void _Python3Output (maxon::TARGETAUDIENCE audience, const Char *str, Int line, const Char *file, maxon::WRITEMETA meta=maxon::WRITEMETA::DEFAULT)
 
void _Python3Output (maxon::TARGETAUDIENCE audience, const maxon::String &str, Int line, const Char *file)
 
void _Python3Output (maxon::TARGETAUDIENCE audience, maxon::StringProxy *proxy, Int line, const Char *file)
 
maxon::Error PrivateRegisterCPythonFunc (const Char *name, py::NativePyCFunctionWithKeywords underlyingFunc3, BaseArray< NativePyCFunctionTable > &functions3)
 
void PrivateCPyRefDiagnosticOutput (MAXON_SOURCE_LOCATION_DECLARATION, const Char *refName, const py::CPyRef &ref)
 
template<typename F >
static auto GetSymbol (const DllRef &dll, const CString &symbol)
 
enum maxon::Errno int MAXON_ENUM_LIST (Errno)
 
enum maxon::CONTAINS int MAXON_ENUM_LIST (CONTAINS)
 
enum maxon::VMSETTINGS MAXON_ENUM_FLAGS (VMSETTINGS)
 
enum maxon::VMINITSETTINGS MAXON_ENUM_LIST (VMINITSETTINGS)
 
enum maxon::ERRORHANDLING MAXON_ENUM_LIST (ERRORHANDLING)
 
void DiagnosticOutputFlags (EntityBase::FLAGS flags)
 
void DiagnosticOutputValueKind (const DataType &dt)
 
enum maxon::DEFAULTRUNTIME MAXON_ENUM_LIST (DEFAULTRUNTIME)
 
 MAXON_REGISTRY (Class< VirtualMachineRef >, VirtualMachines, "net.maxon.python.registry.virtualmachines")
 
 MAXON_REGISTRY (VmDebuggerConnectionRef, VmDebuggerConnections, "net.maxon.python.registry.vmdebuggerconnections")
 
 MAXON_DECLARATION (Class< VirtualMachineScopeRef >, CPythonScope, "net.maxon.python.virtualmachine.scope")
 
 MAXON_REGISTRY (VirtualMachineRef, PythonVms, "net.maxon.python.virtualmachines")
 
 MAXON_REGISTRY (Class< FilterRef >, FilterClasses, "net.maxon.renderfilter.registry.filterclasses")
 
 MAXON_REGISTRY (Class< FilterCommandQueueRef >, FilterCommandQueueClasses, "net.maxon.renderfilter.registry.filtercommandqueueclasses")
 
 MAXON_REGISTRY (Class< FilterContextRef >, FilterContextClasses, "net.maxon.renderfilter.registry.filtercontextclasses")
 
 MAXON_REGISTRY (Class< FilterImageRef >, FilterImageClasses, "net.maxon.renderfilter.registry.filterimageclasses")
 
Block< const Byte > ToBlock (CFDataRef ref)
 
CFAllocatorRef GetCustomCFAllocator ()
 
CGColorSpaceRef GetSystemColorSpace ()
 
CGColorSpaceRef GetColorSpaceSRGB ()
 
Result< void > CGImageToARGB (CGImageRef image, Int width, Int height, void *buf)
 
CFStrongRef< CFStringRef > ToCFString (const String &in)
 
CFStrongRef< CFStringRef > ToCFString (const CString &in)
 
String CFToString (const CFStringRef in)
 
CFStringRef CreateCFString (const String &in)
 
Result< CFStrongRef< CFURLRef > > ToCFURL (const Url &fn)
 
Result< Url > CFURLToUrl (const CFURLRef fn)
 
Result< Url > GetPreferencesPath (Bool localUser)
 
Result< Url > GetApplicationSupportPath (Bool localUser)
 
Bool GetSysCtlString (const char *what, const Block< Char > &out_str)
 
Bool GetSysCtlString (const char *what, Int32 &out)
 
Bool GetSysCtlString (const char *what, UInt64 &out)
 
 MAXON_PREPROCESSOR_CONDITION (defined(MAXON_TARGET_WINDOWS))
 
 MAXON_DECLARATION (Class< Volume >, VOLUME, "net.maxon.volume.class.volume")
 
enum maxon::VOLUMESAMPLER MAXON_ENUM_LIST (VOLUMESAMPLER, "net.maxon.volume.datatype.enum.volumesampler")
 
 MAXON_DATATYPE (GridAccessorBase, "net.maxon.volume.datatype.gridaccessorbaseref")
 
enum maxon::ITERATORTYPE MAXON_ENUM_LIST (ITERATORTYPE)
 
enum maxon::TREEVOXELLEVEL MAXON_ENUM_LIST (TREEVOXELLEVEL)
 
enum maxon::VOLUME_RAY_TYPE MAXON_ENUM_LIST (VOLUME_RAY_TYPE, "net.maxon.volume.datatype.enum.raytype")
 
 MAXON_DATATYPE (VolumeRayIntersectorBase, "net.maxon.volume.datatype.volumerayintersectorbaseref")
 
enum maxon::POLYGONCONVERSIONFLAGS MAXON_ENUM_FLAGS (POLYGONCONVERSIONFLAGS, "net.maxon.volume.datatype.enum.polygonconversionflags")
 
enum maxon::MIXVECTORTYPE MAXON_ENUM_LIST (MIXVECTORTYPE, "net.maxon.volume.datatype.enum.mixvectortype")
 
enum maxon::SDFFILTERTYPE MAXON_ENUM_LIST (SDFFILTERTYPE, "net.maxon.volume.datatype.enum.sdffiltertype")
 
enum maxon::FILTERTYPE MAXON_ENUM_LIST (FILTERTYPE, "net.maxon.volume.datatype.enum.filtertype")
 
enum maxon::VECTORFILTERTYPE MAXON_ENUM_LIST (VECTORFILTERTYPE, "net.maxon.volume.datatype.enum.vectorfiltertype")
 
enum maxon::FILTERACCURACY MAXON_ENUM_LIST (FILTERACCURACY, "net.maxon.volume.datatype.enum.filteraccuracy")
 
 MAXON_DATATYPE (SDFFilterSettings, "net.maxon.volume.datatype.sdffiltersettings")
 
 MAXON_DATATYPE (FilterSettings, "net.maxon.volume.datatype.filtersettings")
 
enum maxon::RESAMPLEINTERPOLATIONTYPE MAXON_ENUM_LIST (RESAMPLEINTERPOLATIONTYPE, "net.maxon.volume.datatype.enum.resampleinterpolationtype")
 
 MAXON_DATATYPE (FieldSampleData, "net.maxon.volume.datatype.fieldsampledata")
 
 MAXON_DATATYPE (VolumeConversionPolygon, "net.maxon.volume.datatype.volumeconversionpolygon")
 

Variables

maxon::CommandAssetInterface MAXON_ENUM_FLAGS
 
const Id URLSCHEME_ASSET
 
const Id URLSCHEME_ASSETDB
 
const Id URLSCHEME_META
 
const Id URLSCHEME_METASQ
 
static const LiteralId ID_MISSINGASSETS
 
maxon::CompactableAssetRepositoryInterface MAXON_ENUM_LIST
 
static constexpr LiteralId PRESET_DEFAULT_CATEGORY
 
static const LiteralId ID_MISSINGNODESPACE
 
static const LiteralId ID_MISSINGPLUGIN
 
template<typename T >
decltype(begin(std::declval< T & >())) TestForBeginFunction (OverloadRank1)
 
template<typename T >
decltype(end(std::declval< T & >())) TestForEndFunction (OverloadRank1)
 
static const NO_MATCH_TYPE NO_MATCH
 
static const UInt32 g_privateDays [2][12]
 
enum Byte
 
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
 
Int alignment
 
struct maxon::ValueKindHelper MAXON_ENUM_ORDERED_FLAGS
 
const ARG & src
 
return OK
 
static const Int BASEARRAY_DEFAULT_CHUNK_SIZE
 
static constexpr Int BLOCKARRAY_DEFAULT_SIZE_EXPONENT
 
const BYTEORDER SYSTEM_BYTEORDER
 
Bool g_hasSSE2
 
Bool g_hasSSE3
 
Bool g_hasSSSE3
 
Bool g_hasSSE4_1
 
Bool g_hasSSE4_2
 
Bool g_hasAVX
 
Bool g_hasFMA
 
Bool g_hasAES
 
Bool g_hasPCLMULQDQ
 
Bool g_hasAVX2
 
MAXON_ATTRIBUTE_DLL_PUBLIC CpuYieldState::SwitchDelegate g_CpuYieldDelegate
 
Bool g_trackSpinlocks
 
Bool g_inCrashhandler
 
const Id DATADESCRIPTION_CATEGORY_DATA
 
const Id DATADESCRIPTION_CATEGORY_UI
 
const Id DATADESCRIPTION_CATEGORY_STRING
 
const Id DATADESCRIPTION_SCOPE_LOCAL
 
static const UInt INITIALIZEHASH
 
static const UInt FINALIZEHASH
 
static const UInt VALIDATEHASH
 
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 const Int JOBQUEUE_USEMAXIMUMTHREADS
 
static const JobQueueInterface::Current JOBQUEUE_CURRENT
 
static const JobQueueInterface::None JOBQUEUE_NONE
 
Char g_writableMemory [1024]
 
static const Int STACKTRACE_SKIP
 
static constexpr Int ADDOBSERVER_DEFAULTPRIORITY
 
static const NO_VALUE_TYPE NO_VALUE
 
static const Int PARALLELFOR_DEFAULTGRANULARITY
 
static const Int PARALLELFOR_MINIMUMGRANULARITY
 
static const Int PARALLELFOR_USEMAXIMUMTHREADS
 
static const Int PARALLELFOR_DISABLETHREADING
 
static const Int PARALLELFOR_MAXIMUMDEPTH
 
static const Float UNKNOWNPROGRESS
 
static const Int DEFAULT_APPENDSIZE
 
static const Int STRING_MAXIMUM_PRECISION
 
static const Int STRING_DYNAMIC_DIGITS
 
static const Id LANGUAGE_ENGLISH_ID
 
System::SPECIALBEHAVIOR g_systemBehavior
 
static const TimeValue MINSLEEPDURATION
 
const Float64 FRAMERATE_DEFAULT
 
const Float64 FRAMERATE_NTSC
 
const Float64 FRAMERATE_PAL
 
const Float64 FRAMERATE_FILM
 
const Float64 FRAMERATE_FILM_NTSC
 
static const TimeValue TIMEVALUE_INFINITE
 
static const TimeValue TIMEVALUE_INVALID
 
static const IgnoredPlaceholder Ignore
 
static const Id URLSCHEME_HANDLER
 
static const Id URLSCHEME_FILESYSTEM
 
static const Id URLSCHEME_AUTHORITY
 
static const Id URLSCHEME_RELATIVE
 
static const Id URLSCHEME_VOLUME
 
static const Id URLSCHEME_NETWORK
 
static const Id URLSCHEME_STORAGE
 
static const Id URLSCHEME_ZIPFILE
 
static const Id URLSCHEME_GZIPFILE
 
static const Id URLSCHEME_MEMORY
 
static const Id URLSCHEME_TCP
 
static const Id URLSCHEME_WS
 
static const Id URLSCHEME_WSS
 
static const Id URLSCHEME_HTTP
 
static const Id URLSCHEME_HTTPS
 
static const Id URLSCHEME_FTP
 
static const Id URLSCHEME_SFTP
 
static const Id URLSCHEME_PERFORCE
 
static const Id URLSCHEME_CRYPTOFILE
 
static const Id URLSCHEME_CACHE
 
static const Id URLSCHEME_PIPE
 
static const Id URLSCHEME_STDOUT
 
static const Id URLSCHEME_STDERR
 
static const Id URLSCHEME_STDIN
 
static const Id URLSCHEME_APK_ASSET
 
static constexpr Float32 MINVALUE_FLOAT32
 
static constexpr Float32 MAXVALUE_FLOAT32
 
static constexpr Float64 MINVALUE_FLOAT64
 
static constexpr Float64 MAXVALUE_FLOAT64
 
static constexpr Float32 MINVALUE_INT32_FLOAT32
 
static constexpr Float32 MAXVALUE_INT32_FLOAT32
 
static constexpr Float64 MINVALUE_INT64_FLOAT64
 
static constexpr Float64 MAXVALUE_INT64_FLOAT64
 
static constexpr Float32 MINRANGE_FLOAT32
 
static constexpr Float32 MAXRANGE_FLOAT32
 
static constexpr Float64 MINRANGE_FLOAT64
 
static constexpr Float64 MAXRANGE_FLOAT64
 
static constexpr Float MINVALUE_FLOAT
 
static constexpr Float MAXVALUE_FLOAT
 
static constexpr Float MINRANGE_FLOAT
 
static constexpr Float MAXRANGE_FLOAT
 
static constexpr Int NOTOK
 
static constexpr Float64 PI
 
static constexpr Float64 PI_INV
 
static constexpr Float64 PI2
 
static constexpr Float64 PI2_INV
 
static constexpr Float64 PI05
 
static constexpr Float64 PI05_INV
 
static constexpr Float64 SQRT2
 
static constexpr Float64 SQRT_PI2
 
static constexpr Float64 SQRT2_INV
 
static constexpr Float64 SQRT3
 
static constexpr Float64 LOG2
 
maxon::Bool g_isDebuggerPresent
 
maxon::Bool g_enableDebugBreak
 
JavaHelper g_javaHelper
 
static const ERROR_FAILED FAILED
 
const Error returns_nonnull
 
static HashSet< ThreadedUIUpdateBaseRef > g_freeThreadedStuff
 
static Spinlock g_freeThreadedStuffLock
 
static FunctionBaseRef g_exitObservable
 
static Bool g_inShutDown
 
static const Float PERCEIVED_BRIGHTNESS_FACTOR_RED
 
static const Float PERCEIVED_BRIGHTNESS_FACTOR_GREEN
 
static const Float PERCEIVED_BRIGHTNESS_FACTOR_BLUE
 
static const Float PERCEIVED_BRIGHTNESS_CUTOFF
 
static const Float POINT_FUSE_EPS
 
const UInt32 Mantissa [2048]
 
const UInt16 Offset [64]
 
const UInt32 Exponent [64]
 
const UInt16 Base [512]
 
const UChar Shift [512]
 
static constexpr Int DYNAMICDEGREE
 
static const Float EPSS
 
static const Int MR
 
static const Int MT
 
static const Int MAXIT
 
static const Float EPS
 
Bool g_enableInCodeProfiler
 
Bool g_enableProfilerDumpRegistry
 
Bool g_enableProfilerDumpRegistryErrors
 
Bool g_enableProfilerGetMethodNameTrace
 
static const Id URLSCHEME_RAMDISK
 
static const Int REGPARSE_CONCAT
 
static const Int REGPARSE_ANYCHAR
 
static const Int REGPARSE_ANYDIGIT
 
static const Int REGPARSE_OPERATOR_OR
 
static const Int REGPARSE_OPERATOR_STAR
 
static const Int REGPARSE_OPERATOR_PARENTHESIS_LEFT
 
static const Int REGPARSE_OPERATOR_PARENTHESIS_RIGHT
 
static const TimeValue NETWORK_DEFAULT_CONNECT_TIMEOUT
 
static const TimeValue NETWORK_DEFAULT_SESSION_TIMEOUT
 
static const TimeValue SOCKETTIMEOUT_INDEFINITELY
 
static const TimeValue SOCKETTIMEOUT_NEVERBLOCK
 
static const WILDCARD_IPV4_ADDRESS_TYPE WILDCARD_IPV4_ADDRESS
 
static const WILDCARD_IPV6_ADDRESS_TYPE WILDCARD_IPV6_ADDRESS
 
static const Int WILDCARD_IP_PORT
 
const Id ID_LOGGER_PYTHON
 
const Int32 NATIVE_CO_MAXBLOCKS
 

Typedef Documentation

◆ InsertPointType

using InsertPointType = Tuple<Id, Vector, Vector2d, ColorA>

◆ OutputStreamDecoratorFactory

using OutputStreamDecoratorFactory = Delegate<Result<OutputStreamRef>(const OutputStreamRef& stream)>

A delegate which receives an output stream as parameter and returns either that stream itself or a wrapper stream which decorates the original stream.

Parameters
[in]streamThe stream to decorated.
Returns
The decorated stream, may be stream itself.

◆ AssetRepositoryUpdate

using AssetRepositoryUpdate = Tuple<AssetDescription, BaseArray<AssetBase> >

A tuple where the asset description represents an asset in a repository and the array lists other assets to which the asset's references can be updated. For example if asset A has links to assets B1, C1 but there are newer versions B2, C2, then this is represented by the tuple (A, [B2, C2]).

◆ BuiltinAssetLoader

using BuiltinAssetLoader = Delegate<Result<Bool>(const Block<const Id>& types, const Id& aid, ASSET_FIND_MODE findMode, const ValueReceiver<const Asset&, const DataDictionary&>& receiver)>

A BuiltinAssetLoader is used by the built-in asset repository to find built-in assets. You can register such a loader at the BuiltinAssetLoaders registry to add new built-in assets.

Parameters
[in]typesThe allowed asset types.
[in]aidThe asset identifier to lookup, use an empty identifier to find all assets.
[in]findModeFlags for the lookup.
[in]receiverAll found assets (plus their meta data) are reported to this receiver.
Returns
false if the receiver cancelled further evaluation, true otherwise.

◆ DndAsset

using DndAsset = Tuple<AssetDescription, Url, String >

Tuple with d&d asset data AssetDescription: asset Url: of the asset String: searchString at the time when the d&d was initiated.

◆ AddAssetMetaData

using AddAssetMetaData = HashMap<InternedId, Tuple<Data, AssetMetaDataInterface::KIND> >

◆ PresetStorage

using PresetStorage = DataDictionary

◆ DataDescriptionEntry

typedef DataDictionary DataDescriptionEntry

◆ LanguageStringDataDescriptionDefinition

typedef HashMap< Id, DataDescriptionDefinition > LanguageStringDataDescriptionDefinition

◆ LanguageDictionary

using LanguageDictionary = DataDictionary

◆ NimbusForwardRef

using NimbusForwardRef = ForwardRefWithExtraBase<NimbusRef, NimbusBaseRef>

◆ CustomLicenseItemDelegate

using CustomLicenseItemDelegate = Delegate<Result<void>(const InternedId& featureId, const String& provider, Bool isValid, const CString& jwtString)>

◆ NodeMaterialLinkResolveFunc

using NodeMaterialLinkResolveFunc = Delegate<Result< ::BaseList2D*>( ::BaseLink* link, ::BaseDocument* baseDocument)>

This delegate allows to custom-define a link resolution to map from Uuid to BaseList2D, for example using another document.

◆ DescCompareEntry

using DescCompareEntry = Tuple<Bool, BaseContainer, DescID, maxon::String>

◆ CommandGetStateDelegate

using CommandGetStateDelegate = Delegate<Int32(::BaseDocument*)>

◆ CreateMaterialWithDataDelegate

using CreateMaterialWithDataDelegate = Delegate<::BaseMaterial*(::BaseDocument*, const Data& textureUrlOrColor)>

Allows to register a delegate which will be called when a new material of your type is created from a texture or color (for example when drag&dropping a texture file, a texture asset or a color into the Material Manager) where you must set the data into the material properly. Additionally, your material will appear into the "Cinema 4D Preferences / Material / Material Manager / Default Material" dropdown. Example of use:

// Register Sketch & Toon material
Bool RegisterToonUpMat(void)
{
return RegisterMaterialPlugin(ID_TOONUP_MAT, GeLoadString(IDS_TOONUPMAT), PLUGINFLAG_MATERIAL_SHOW_IN_DEFAULT_MENU | PLUGINFLAG_HIDEPLUGINMENU | PLUGINFLAG_HIDE, ToonUpMat::Alloc, "Mtoonup"_s, TOONUP_LEVEL_ID);
}
// Register create material delegate
namespace maxon
{
MAXON_DECLARATION_REGISTER(CreateMaterialWithDataDelegates, NumToString<ID_TOONUP_MAT>::value)
{
CreateMaterialWithDataDelegate delegate = [](::BaseDocument* doc, const Data& textureUrlOrColor) -> ::BaseMaterial*
{
//-----------------------------------------------------------
// Create Skecth&Toon material
//-----------------------------------------------------------
// First try to create a user preset default material
BaseMaterial* mat = (BaseMaterial*)AssetCreationInterface::GetDefaultObject(ToSingletonBlock(ID_TOONUP_MAT), doc);
if (!mat)
{
// There is no default preset material: create a new one.
mat = BaseMaterial::Alloc(ID_TOONUP_MAT);
if (!mat)
{
CriticalStop("Hair material creation error: out of memory");
return nullptr;
}
}
//-----------------------------------------------------------
// Set data to material (if any)
//-----------------------------------------------------------
ifnoerr (maxon::Url url = textureUrlOrColor.Get<maxon::Url>())
{
//-----------------------------------------------------------
// Received data is a texture url: set it into the material
//-----------------------------------------------------------
// Activate "Texture" checkbox
mat->SetParameter(DescLevel(OUTLINEMAT_COLOR_TEXTURE), true, DESCFLAGS_SET::NONE);
// Set texture url
BaseContainer* bc = mat->GetDataInstance();
// Delete any unexpected shader (take in mind that if material is a user preset default material, it may contain some unexpected shader)
BaseShader* oldShader = (BaseShader*)bc->GetLink(OUTLINEMAT_COLOR_TEXTURE_LINK, doc, Xbase);
if (oldShader)
BaseShader::Free(oldShader);
BaseShader* newShader = BaseShader::Alloc(Xbitmap);
if (newShader != nullptr)
{
newShader->GetDataInstance()->SetFilename(BITMAPSHADER_FILENAME, MaxonConvert(url));
// Material takes shader ownership
mat->InsertShader(newShader);
// Set parameter link
mat->SetParameter(DescLevel(OUTLINEMAT_COLOR_TEXTURE_LINK), newShader, DESCFLAGS_SET::NONE);
}
}
else
{
ifnoerr (maxon::ColorA color = textureUrlOrColor.Get<maxon::ColorA>())
{
//-----------------------------------------------------------
// Received data is a color: set it into the material
//-----------------------------------------------------------
// Set main color
mat->SetParameter(DescLevel(OUTLINEMAT_COLOR), color.GetColor3().GetVector(), DESCFLAGS_SET::NONE);
// Set transparency from alpha component
mat->SetParameter(DescLevel(OUTLINEMAT_OPACITY), color.a, DESCFLAGS_SET::NONE);
}
}
return mat;
};
return delegate;
}
}
value
PyObject * value
Definition: abstract.h:715
MaxonConvert
maxon::Url MaxonConvert(const Filename &fn, MAXONCONVERTMODE convertMode)
RegisterMaterialPlugin
Bool RegisterMaterialPlugin(Int32 id, const maxon::String &str, Int32 info, DataAllocator *g, const maxon::String &description, Int32 disklevel)
GeLoadString
const String & GeLoadString(Int32 id)
BaseContainer
Definition: c4d_basecontainer.h:47
BaseContainer::SetFilename
void SetFilename(Int32 id, const Filename &f)
Definition: c4d_basecontainer.h:583
BaseContainer::GetLink
BaseList2D * GetLink(Int32 id, const BaseDocument *doc, Int32 instanceof=0) const
Definition: c4d_basecontainer.h:443
BaseDocument
Definition: c4d_basedocument.h:498
BaseList2D::InsertShader
void InsertShader(BaseShader *shader, BaseShader *pred=nullptr)
Definition: c4d_baselist.h:2573
BaseList2D::GetDataInstance
const BaseContainer * GetDataInstance() const
Definition: c4d_baselist.h:2328
BaseMaterial
Definition: c4d_basematerial.h:28
BaseMaterial::Alloc
static BaseMaterial * Alloc(Int32 type)
BaseShader
Definition: c4d_basechannel.h:36
BaseShader::Alloc
static BaseShader * Alloc(Int32 type)
BaseShader::Free
static void Free(BaseShader *&ps)
C4DAtom::SetParameter
Bool SetParameter(const DescID &id, const GeData &t_data, DESCFLAGS_SET flags)
maxon::AssetCreationInterface::GetDefaultObject
static MAXON_METHOD BaseList2D * GetDefaultObject(const Block< const Int32 > &id, BaseDocument *doc)
maxon::Url
Definition: url.h:942
maxon::Url::Get
Result< typename std::conditional< STD_IS_REPLACEMENT(void, T), typename IsFidClass< KEY >::type, T >::type > Get(KEY &&key) const
Definition: url.h:1002
Bool
maxon::Bool Bool
Definition: ge_sys_math.h:55
DESCFLAGS_SET::NONE
@ NONE
None.
PLUGINFLAG_MATERIAL_SHOW_IN_DEFAULT_MENU
#define PLUGINFLAG_MATERIAL_SHOW_IN_DEFAULT_MENU
If set, material will appear in Preferences / Material / Material Manager / Default Material dropdown...
Definition: c4d_materialdata.h:38
PLUGINFLAG_HIDEPLUGINMENU
#define PLUGINFLAG_HIDEPLUGINMENU
Hide the plugin's menu entry.
Definition: c4d_baseplugin.h:31
PLUGINFLAG_HIDE
#define PLUGINFLAG_HIDE
Hide the plugin (for example, in Commander).
Definition: c4d_baseplugin.h:29
maxon::ToSingletonBlock
Block< T > ToSingletonBlock(T &value)
Definition: block.h:983
MAXON_DECLARATION_REGISTER
#define MAXON_DECLARATION_REGISTER(...)
Definition: module.h:923
ifnoerr
#define ifnoerr(...)
The opposite of iferr.
Definition: errorbase.h:393
CriticalStop
#define CriticalStop(...)
Definition: debugdiagnostics.h:237
Xbase
#define Xbase
Shader base.
Definition: ge_prepass.h:1294
Xbitmap
#define Xbitmap
Bitmap.
Definition: ge_prepass.h:1296
OUTLINEMAT_COLOR_TEXTURE
@ OUTLINEMAT_COLOR_TEXTURE
Definition: moutliner.h:615
OUTLINEMAT_OPACITY
@ OUTLINEMAT_OPACITY
Definition: moutliner.h:1045
OUTLINEMAT_COLOR
@ OUTLINEMAT_COLOR
Definition: moutliner.h:579
OUTLINEMAT_COLOR_TEXTURE_LINK
@ OUTLINEMAT_COLOR_TEXTURE_LINK
Definition: moutliner.h:616
maxon
The maxon namespace contains all declarations of the MAXON API.
Definition: autoweight.h:14
maxon::CreateMaterialWithDataDelegate
Delegate<::BaseMaterial *(::BaseDocument *, const Data &textureUrlOrColor)> CreateMaterialWithDataDelegate
Definition: createdefaultmaterialdelegate.h:102
doc
const char * doc
Definition: pyerrors.h:226
DescLevel
Represents a level within a DescID.
Definition: lib_description.h:289
maxon::Col4
A color consisting of three components R, G, B and an alpha.
Definition: col4.h:16
BITMAPSHADER_FILENAME
@ BITMAPSHADER_FILENAME
Definition: xbitmap.h:6

◆ CreateDefaultMaterialDelegate

using CreateDefaultMaterialDelegate = Delegate<::BaseMaterial*(::BaseDocument*)>

◆ PyBaseElementFactoryType

using PyBaseElementFactoryType = Factory<PythonElementBaseRef(BaseList2D* bl)>

◆ PyEmbeddedElementFactoryType

using PyEmbeddedElementFactoryType = Factory<PythonElementEmbeddedRef(BaseList2D* bl, const DescID& parameter)>

◆ PyDirectoryElementFactoryType

using PyDirectoryElementFactoryType = Factory<PythonElementBaseRef(Url dir)>

◆ PyScriptElementFactoryType

using PyScriptElementFactoryType = Factory<PythonElementScriptRef(BaseList2D* bl)>

◆ GetExtraDataCallbackType

using GetExtraDataCallbackType = Delegate<DelegateBase(const Id&)>

◆ PatchC4DDescriptionEntryDelegate

using PatchC4DDescriptionEntryDelegate = Delegate<Result<void>(BaseContainer& param)>

◆ CommandCacheMap

using CommandCacheMap = HashMap<Id, CommandCacheRef>

◆ CommandCacheDataRef

using CommandCacheDataRef = StrongRef<CommandCacheData>

◆ ABIReturnType

using ABIReturnType = ABIParamType<T>

ABIReturnType<T>::type is an erased type which is compatible with T with respect to the calling convention of the ABI when used for a return value.

See also
ABIParamType
Template Parameters
TType for which the erased, ABI-compatible return type shall be determined.

◆ IndexPair

using IndexPair = Pair<Int, Int>

◆ WritableArrayInterface

using WritableArrayInterface = const NonConstArray<T>

WritableArrayInterface is used for function parameters which shall be able to receive any kind of standard array of the MAXON API via the ArrayInterface interface mechanism. You have to use WritableArrayInterface instead of ArrayInterface if you want to modify the array within the function. Example:

void Func(WritableArrayInterface<Char>& array);
BlockArray<Char> myArray;
Func(myArray); // OK
BaseArray<Char> myArray2;
Func(myArray2); // OK
See also
ArrayInterface

◆ BackgroundEntryTuple

using BackgroundEntryTuple = Tuple<WeakRef<BackgroundProgressRef>, Int>

DataType which is added to the url (URLFLAGS::BACKGROUNDJOB) when calling a c4d scene filter/loader maxon::Url url = MaxonConvert(name, MAXONCONVERTMODE::NONE); maxon::BackgroundEntryTuple backgroundJob = url.Get(maxon::URLFLAGS::BACKGROUNDJOB, maxon::BackgroundEntryTuple()); maxon::BackgroundProgressRef job = backgroundJob.first; if (job) { // add the master backgroundJob.second = job.AddProgressJob(1.0, String()) iferr_return; }

◆ BitSet

using BitSet = BaseBitSet<DefaultAllocator>

◆ PersistentIdBuffer

using PersistentIdBuffer = BufferedBaseArray<Int64, 10>

◆ CrashReportPropertyArray

using CrashReportPropertyArray = BlockArray<CrashReportPropertyItem, 8>

◆ DataDescriptionWithUIAndString

using DataDescriptionWithUIAndString = Tuple<DataDescription , DataDescription , DataDescription >

◆ LanguageStringDataDescription

using LanguageStringDataDescription = HashMap<Id , DataDescription>

◆ DataDescriptionWithUIAndLanguageStrings

using DataDescriptionWithUIAndLanguageStrings = Tuple<DataDescription , DataDescription , LanguageStringDataDescription >

◆ VariadicIdsElement

using VariadicIdsElement = Tuple<Int, Id, String, HashMap<Id, Int > >

◆ VariadicIdsType

using VariadicIdsType = Array<VariadicIdsElement>

◆ ContextVarTuple

using ContextVarTuple = Tuple<DataDictionary, GetDataCallbackType>

Tuple which stores the parameters (DataDictionary) of a function call and provides the GetDataCallbackType to evaluate conditions.

◆ ContextVarsMap

using ContextVarsMap = HashMap<Id, ContextVarTuple>

Hash map which stores ContextVarTuple for commands.

◆ GetDescEntriesCallbackType

using GetDescEntriesCallbackType = Delegate<Result<Tuple<InternedId, DataDictionary, DataDictionary> >(const InternedId& id, GETDATAFLAGS flags)>

Callback type used for EvaluateCondition which cannot be given a set of descriptions up front. Can also be used to re-path/edit the given #id if needed. For instance, evaluating conditions on a bundle child port needs a relative path that includes the parent ports.

Parameters
[in]idThe id to evaluate, extracted from #condition in EvaluateCondition.
[in]flagsThe evaluation flags, from EvaluateCondition.
Returns
The modified id (later passed to the GetDataCallbackType delegate call), the "data" description entry, the "gui" description entry.

◆ ConditionToken

using ConditionToken = Tuple<const CString&, const CString&, CONDITIONTOKENTYPE>

◆ ProcessEnumListDelegate

using ProcessEnumListDelegate = Delegate<Result<void>(const Id& epId, const DataDictionary& guiEntry, const AssetRepositoryRef& repository, const Data* filterData, const ValueReceiver<Tuple<Id, Data, String>&&>& addValue)>

Callback for registry ProcessEnumListDelegates.

Parameters
[in]epIdThe extension point identifier (for instance "node", "enum", ...).
[in]guiEntryThe description definition DATADESCRIPTION_CATEGORY_GUI entry which defines the enum or preset.
[in]repositoryRepository from where the entries stem.
[in]filterDataSee UseFilterData.
[in]addValueValueReceiver that will be called to process all enum entries generated by the extension point.
Returns
Ok on success.

◆ EnumVariableResolveDelegate

using EnumVariableResolveDelegate = Delegate<Result<CString>(const CString& variable, const CString& fullString, const AssetRepositoryRef& repository, const GetDataCallbackType& getDataCallback, Opt<const DataDictionary&> dataEntry, Opt<const DataDictionary&> guiEntry)>

Callback for registry EnumVariableResolveDelegates.

Parameters
[in]variableThe variable to replace.
[in]fullStringThe full context in which variables are being resolved.
[in]repositoryRepository from where the entries stem.
[in]getDataCallbackCallback used to read read description entry values.
[in]dataEntryOptional. The description definition DATADESCRIPTION_CATEGORY_DATA entry which defines the enum or preset.
[in]guiEntryOptional. The description definition DATADESCRIPTION_CATEGORY_GUI entry which defines the enum or preset.
Returns
A resolved string, should contain no more "{}". Can be turned in an Id or replaced in original string by caller. An error if the variable could not be resolved.

◆ GetDataCallbackType

using GetDataCallbackType = Delegate<Result<Data>(const InternedId& id, const DataDictionary& dataEntry, GETDATAFLAGS flags)>

◆ DataDescriptionDefinitionWithUIAndLanguageStrings

using DataDescriptionDefinitionWithUIAndLanguageStrings = Tuple<DataDescriptionDefinition , DataDescriptionDefinition , LanguageStringDataDescriptionDefinition >

◆ BuildSubMenuValueReceiver

using BuildSubMenuValueReceiver = ValueReceiver<SubMenuEntry&&>

Value receiver for menu entries. Id - id of the category to add the entry. Empty Id() for no category. SubMenuEntry - entry with the data to present.

◆ DescriptionMessageCheck

using DescriptionMessageCheck = Delegate<Result<DESCRIPTIONMESSAGECHECKFLAGS>(const DataDictionary& userData)>

Optional delegate to return a pre message check for a description command. DESCRIPTIONMESSAGECHECKFLAGS will be evaluated to disable, hide or check the menu entry.

◆ DescriptionMessageBuildSubMenu

using DescriptionMessageBuildSubMenu = Delegate<Result<void>(const DataDictionary& userData, const BuildSubMenuValueReceiver& menuEntries)>

Optional delegate to return a sub menu structure of a registered description command.

◆ DescriptionMessageCall

using DescriptionMessageCall = Delegate<Result<void>(const DataDictionary& userData, DataDictionary& multiSelectionStorage)>

Delegate which will be called on execution of a registered command.

◆ DescriptionMessageFunction

using DescriptionMessageFunction = Tuple<Id, DescriptionMessageCheck, DescriptionMessageBuildSubMenu, DescriptionMessageCall>

Combines all delegates for a command registration.

Id: DESCRIPTION::UI::BASE::COMMANDCONTEXT context to which the command belongs to

DescriptionMessageCheck: Callback for the check before presenting the command. This allows to control visibility, enabling, checking,

DescriptionMessageBuildSubMenu: Optional callback to create a submenu structure for this menu entry.

DescriptionMessageCall: Callback for the execution of the command. This must be nullptr if a submenu is provided.

◆ DataFormatReaderFactory

using DataFormatReaderFactory = Factory<DataFormatReaderRef(UrlOrInputStream&&)>

◆ DataFormatWriterFactory

using DataFormatWriterFactory = Factory<DataFormatWriterRef(UrlOrOutputStream&&)>

◆ KeyValueConversionFunc

using KeyValueConversionFunc = void(void*, Char*)

◆ CreateIoHelperFunc

using CreateIoHelperFunc = ResultPtr<void>()

◆ DeleteIoHelperFunc

using DeleteIoHelperFunc = void(void*)

◆ ReadIoHelperFunc

using ReadIoHelperFunc = Result<void>(DataSerializeInterface*, void*, void*, UInt)

◆ WriteIoHelperFunc

using WriteIoHelperFunc = Result<void>(DataSerializeInterface*, void*, void*, UInt)

◆ WidthConversionFunc

using WidthConversionFunc = Bool(void* source, void* dest)

Conversion function for AddWidthConversion from a source to a destination datatype.

Parameters
[in]sourceThe address of the source datatype.
[in]destThe address of the destination datatype.
Returns
True if a conversion was possible, false otherwise.

◆ ReferenceSubstitutionFunction

using ReferenceSubstitutionFunction = Delegate<Result<const ObjectInterface*>(const ObjectInterface* input)>

Substitution function for RegisterObjectSubstitution. The returned ObjectInterface* can be identical to 'input', in that case no substitution takes place. So e.g. only certain types of objects can be translated. Please note that when you create the substitution objects you need to make sure to hold all references yourself (until the complete I/O operation is finished) as the substitution function only returns a pointer and not a reference. Please also note that the input object during reading has the same pointer address it still may be a different object as it is only a temporary object and thus can be at the same address as a previous object.

Parameters
[in]inputThe virtual object created from reading or writing.
Returns
The substituted object.

◆ StreamSubstitutionFunction

using StreamSubstitutionFunction = Delegate<Result<ObjectRef>(ObjectRef input, const Id& compressorId)>

◆ GetChildrenTypesCallback

using GetChildrenTypesCallback = Delegate<Result<Tuple<String, Bool> >(const Member& elementType, const ParametricTypeInterface* parametricType)>

◆ GetDataTypeNameDelegate

using GetDataTypeNameDelegate = Delegate<Result<Tuple<String, String> >(DATATYPEBUILDERNAME category, const DataType& dt, const GetChildrenTypesCallback& getChildrenTypes, const ParametricTypeInterface* parentTypeId, const ParametricTypeInterface** skipParentType)>

◆ GetChildrenCountDelegate

using GetChildrenCountDelegate = Delegate<Tuple<Int, Int, Bool>()>

◆ InstantiateDataTypeDelegate

using InstantiateDataTypeDelegate = Delegate<Result<DataType>(const BaseArray<Member>& members)>

◆ GetParentTypeSupportDelegate

using GetParentTypeSupportDelegate = Delegate<Block<ParametricType>()>

◆ GetFolderDelegate

using GetFolderDelegate = Delegate<Block<const Id>()>

◆ RemoteDateTime

using RemoteDateTime = LocalDateTime

◆ ObjectBaseRef

using ObjectBaseRef = typename maxon::details::ObjectBaseRefImpl<I::REFERENCE_KIND>::type

◆ ValueReceiver

using ValueReceiver = Delegate<Result<Bool>(T...)>

ValueReceiver is a type alias for a Delegate which receives values of the given type(s) T and returns Result<Bool>. ValueReceiver can be used as parameter type of a function which shall generate a number of values of type T in succession. The function will call the receiver once for each such value, and the receiver has the chance to cancel the supply of further values by returning false.

For example a generator function which yields all positive numbers to a ValueReceiver looks like

Result<void> GetPositiveNumbers(const ValueReceiver<Int>& receiver)
{
iferr_scope;
for (Int i = 1; ; ++i)
{
Bool b = receiver(i) iferr_return;
if (!b)
return OK;
}
}
i
Py_ssize_t i
Definition: abstract.h:645
Int
maxon::Int Int
Definition: ge_sys_math.h:64
maxon::OK
return OK
Definition: apibase.h:2667
iferr_scope
#define iferr_scope
Definition: resultbase.h:1374
iferr_return
#define iferr_return
Definition: resultbase.h:1465

All arrays and sets have conversion functions to a ValueReceiver which appends the supplied value to them. So if you want to write a function which shall return a number of values of type T by adding them to a caller-provided array, you can use a ValueReceiver instead of an array for the function parameter. This will not only allow arrays, but arbitrary functions which can even cancel the function if no further values are needed.

Template Parameters
TTypes of values produced by the generator function.

◆ QueryStartupOrder

using QueryStartupOrder = void (*)(BaseArray<Url>& dllsToLoad)

◆ FactoryBase

using FactoryBase = RefBase<FactoryFunctions<FACTORY, FactoryInterface::ReferenceFunctions<RefBaseFn<DirectRef<const FactoryInterface, StrongRefHandler, FACTORY> >> >>
private

◆ Group

using Group = void

special datatype for groups.

◆ IdAndVersion

using IdAndVersion = Tuple<Id, Id>

IdAndVersion is used for assets to store the asset id (first) and version (second) in a single tuple.

◆ IoProgressDelegate

using IoProgressDelegate = Delegate<Result<void>(Int64 alreadyRead, Int64 totalBytes)>

IoProgressDelegate is used in Url::IoCopyFile to log the progress of the file copy.

Parameters
[in]alreadyReadNumber of bytes already read.
[in]totalBytesNumber of total bytes.
Returns
OK or error. The error could be used to cancel the read operation.

◆ CreateNewMachineCallback

using CreateNewMachineCallback = Delegate<Result<MachineRef>(const String& machineUuid)>

Callback used by FindOrAddRPCMachine. This callback will be called when the machine is not already registered and must be created new.

◆ CheckExistingMachineCallback

using CheckExistingMachineCallback = Delegate<Result<void>(const MachineRef& machineRef)>

Callback used by FindOrAddRPCMachine. This callback will be called when the machine is already registered and will be reused.

◆ CreateObjectRefFunc

using CreateObjectRefFunc = ObjectRef(*)()

Registry to extend MachineInterface::GetInterface(Id)

Returns
ObjectRef to the interface.

◆ WritableMapInterface

using WritableMapInterface = const NonConstMap<K, V>

WritableMapInterface is used for function parameters which shall be able to receive any kind of standard map of the MAXON API via the MapInterface interface mechanism. You have to use WritableMapInterface instead of MapInterface if you want to modify the map within the function. Example:

void Func(WritableMapInterface<Int, String>& map);
HashMap<Int, String> myMap;
Func(myMap); // OK
ArrayMap<Int, String> myMap2;
Func(myMap2); // OK
See also
MapInterface

◆ MultiIndex64

using MultiIndex64 = MultiIndex<UInt64>

◆ ObservableForwardFunction

using ObservableForwardFunction = Result<Data> (*)(const DelegateBase& observerFunction, const Block<const ConstDataPtr>& data)

◆ FunctionBaseWeakRef

using FunctionBaseWeakRef = WeakRef<FunctionBaseRef>

◆ Optional

using Optional = Opt<T>

◆ MinimalElements

using MinimalElements = MaximalElements<T, ARRAY, COMPARE, KEEP_DUPLICATES, true>

MinimalElements finds the minimal elements of a set of values with a partial order. A minimal element of such a set is an element which is not greater than any other element of the set. A partially ordered set may have more than one minimal element.

To use MinimalElements, add all values via the Append function. Afterwards, you can use MinimalElements like an array, it then will contain the minimal elements of all added values.

For comparison, MinimalElements uses the operator < on the values by default (or <= when KEEP_DUPLICATES is true), but you can override this with the #COMPARE parameter.

Template Parameters
TThe type of values. There has to be a partial order on T defined by COMPARE.
ARRAYAn array selector template to choose the array implementation to use.
COMPAREThe static LessThan function (or LessThanOrEqual when KEEP_DUPLICATES is true) of COMPARE is used for value comparisons.
KEEP_DUPLICATESIf true, elements of the set which are equal will be kept each in the array, otherwise only one of them will be in the array.
See also
MaximalElements

◆ JobCancelDelegate

using JobCancelDelegate = Delegate<Result<void>(const ProgressRef& progressRef)>

Delegate used in the ProgressInterface to react on the request to cancel the job.

◆ SecureRandomProvider

using SecureRandomProvider = Pointer<_SecureRandomProvider>

◆ PartialSumSequence

using PartialSumSequence = typename maxon::details::PartialSumSequenceHelper<ZERO_BASED, std::index_sequence<>, 0, VALUES...>::type

◆ WritableSetInterface

using WritableSetInterface = const NonConstSet<T>

WritableSetInterface is used for function parameters which shall be able to receive any kind of standard set of the MAXON API via the SetInterface interface mechanism. You have to use WritableSetInterface instead of SetInterface if you want to modify the set within the function. Example:

void Func(WritableSetInterface<Char>& set);
ArraySet<Char> mySet;
Func(mySet); // OK
HashSet<Char> mySet2;
Func(mySet2); // OK
See also
SetInterface

◆ StreamConversionFactory

using StreamConversionFactory = Factory<StreamConversionRef(const DataDictionary&)>

◆ Synchronized

using Synchronized = SynchronizedValue<T, Spinlock>

Synchronized<T> is an alias for SynchronizedValue<T, Spinlock>.

Template Parameters
TType of the contained value.

◆ RWSynchronized

using RWSynchronized = SynchronizedValue<T, ARWLock>

RWSynchronized<T> is an alias for SynchronizedValue<T, ARWLock>.

Template Parameters
TType of the contained value.

◆ ExecuteProgramCallback

using ExecuteProgramCallback = Int32 (*)(SystemProcessObjectRef processRef, EXECUTEPROGRAMCALLBACK cmd, void* userdata, const Url& logfile)

Callback for SystemProcessInterface::StartProcessAndWait return values: return 0 to continue

◆ Pair

using Pair = typename maxon::details::PairSelector<T1, T2>::type

Pair<T1, T2> is an alias for Tuple<T1, T2>.

◆ HomogenousTupleType

using HomogenousTupleType = typename maxon::details::HomogenousTupleTypeHelper<N, T>::type

Type alias to generate a tuple containing N times type T, i.e. HomogenousTupleType<3, Int> is Tuple<Int, Int, Int>.

◆ UnitsArray

using UnitsArray = StrongCOWRef<BaseArray<Unit> >

◆ ResultPtr

using ResultPtr = ResultMemT<T*>

ResultPtr<T> wraps a pointer. When the pointer is nullptr, this has to be interpreted as an out-of-memory error condition.

ResultPtr<T> can be used instead of the more general Result<T*> when only out-of-memory conditions can occur in a function. It will lead to more efficient code.

All error handling features of the MAXON API (such as iferr, iferr_return and Result) support ResultPtr.

ResultPtr<T> is just a type alias for ResultMemT<T*>.

◆ ThreadedUIUpdateBaseRef

using ThreadedUIUpdateBaseRef = StrongRef<ThreadedUIUpdateBase>

◆ SingleValueReceiver

using SingleValueReceiver = UniqueValueReceiver<T, ERROR_WHEN_AMBIGUOUS>

SingleValueReceiver will get deprecated.

◆ LIBSSH2_PASSWD_CHANGEREQ_FUNC

using LIBSSH2_PASSWD_CHANGEREQ_FUNC = void(*)(LIBSSH2_SESSION *session, char **newpw, int *newpw_len, void **abstract)

◆ sslctxsetverifycallback

typedef int(* sslctxsetverifycallback) (int, X509_STORE_CTX *)

◆ SimplePolygon

using SimplePolygon = Poly<Int32>

Polygon class for simple triangles/quadrangles that is compatible with Melange. It uses Int32 as data type while the new MeshPolygon uses MeshValue/UInt32.

◆ UVWPolygon

using UVWPolygon = Poly<Vector>

◆ TangentPair

using TangentPair = Tuple<Vector, Vector>

◆ TangentPair2d

using TangentPair2d = Tuple<Vector2d, Vector2d>

< 3d Tangent basic data type

◆ TimeStamp

using TimeStamp = UInt64

◆ GraphConnection

using GraphConnection = Tuple<GraphNode, Wires>

GraphConnection represents a connection between two ports of a graph. For a pair of connected ports, one GraphConnection is stored at the source port and another one at the target port. The first tuple value represents the other end of the connection, the second tuple value the wires modes of the connection.

◆ IoNodePath

using IoNodePath = Tuple<NodePath, InternedId>

IoNodePath represents a path to a node and port (port is optional). Tuple<node absolute path, port relative path (single id if port is top-level)>.

◆ IoNodeConnection

using IoNodeConnection = Tuple<IoNodePath, IoNodePath>

IoNodeConnection represents the start and end points of a connection. Tuple<source node and port path, node and port path>.

◆ IoGraphNode

using IoGraphNode = Tuple<GraphNode, InternedId>

◆ GraphAttributeMap

using GraphAttributeMap = HashMap<InternedId, ConstDataPtr>

A GraphAttributeMap collects the current values of attributes of a node or port, see GraphModelInterface::GetValues.

◆ PathBlock

using PathBlock = Block<const InternedId>

A PathBlock is a Block of identifiers to be used as path into a graph, see NodePath.

◆ DrawDimensionInt

using DrawDimensionInt = DrawDimension<Int>

DrawDimension for Int types.

◆ DrawDimensionFloat

using DrawDimensionFloat = DrawDimension<Float>

DrawDimension for Float types.

◆ DrawRectInt

using DrawRectInt = DrawRect<Int>

DrawRect for Int types.

◆ DrawRectFloat

using DrawRectFloat = DrawRect<Float>

DrawRect for Float types.

◆ DrawPoint3dInt

using DrawPoint3dInt = DrawPoint3d<Int>

DrawPoint3d for Int types.

◆ DrawPoint3dFloat

using DrawPoint3dFloat = DrawPoint3d<Float>

DrawPoint3d for Float types.

◆ DrawDimension3dInt

using DrawDimension3dInt = DrawDimension3d<Int>

DrawDimension3d for Int types.

◆ DrawDimension3dFloat

using DrawDimension3dFloat = DrawDimension3d<Float>

DrawDimension3d for Float types.

◆ DrawVolumeInt

using DrawVolumeInt = DrawVolume<Int>

DrawVolume for Int types.

◆ DrawVolumeFloat

using DrawVolumeFloat = DrawVolume<Float>

DrawVolume for Float types.

◆ UpdateRegion

using UpdateRegion = Range<IntVector2d>

Typedef for a Update Region which contains the boundary of a modified range of pixels.

◆ BitDepthConfig

using BitDepthConfig = const DataType

◆ MediaOutputSelectionHandler

using MediaOutputSelectionHandler = Delegate<Result<SELECTIONHANDLERRESULT>(const MediaStreamRef& stream, const MediaStreamFormat& props)>

The selection handler will be called for every stream which is detected in output texture.

◆ MediaSessionProgressCallback

using MediaSessionProgressCallback = Delegate<void(const ProgressRef& progress, Float percent, const TimeValue& duration, const TimeValue& expectedTotalTime)>

Delegate which is triggered if MediaSession loaders notify about some progress when loading files.

Parameters
[in]progressProgressRef which notifies.
[in]percentoverall percent of the progress
[in]durationtime since the operation started.
[in]expectedTotalTimerough guess how load the operatin will take in total.

◆ AnimBlendTweenCallback

using AnimBlendTweenCallback = Delegate<void(const BlendAnimationRef& self, const BlendTweenRef& tween, ANIMBLENDSTATE state, const Data& animValue)>

◆ Complex32

using Complex32 = Complex<Float32>

Single-precision complex number.

◆ Complex64

using Complex64 = Complex<Float64>

Double-precision complex number.

◆ MatrixNxM32

using MatrixNxM32 = MatrixNxM<Float32>

Single-precision n x m matrix.

◆ MatrixNxM64

using MatrixNxM64 = MatrixNxM<Float64>

Double-precision n x m matrix.

◆ MatrixNxMComplex32

using MatrixNxMComplex32 = MatrixNxM<Complex32>

single-precision complex n x m matrix.

◆ MatrixNxMComplex64

using MatrixNxMComplex64 = MatrixNxM<Complex64>

Double-precision complex n x m matrix.

◆ PRSMatrix64

using PRSMatrix64 = PRSMatrixData<Vector64>

◆ PRSMatrix32

using PRSMatrix32 = PRSMatrixData<Vector32>

◆ PRSMatrix

using PRSMatrix = PRSMatrixData<Vector>

◆ Quaternion32

using Quaternion32 = Quaternion<Float32>

Single-precision quaternion.

◆ Quaternion64

using Quaternion64 = Quaternion<Float64>

Double-precision quaternion.

◆ enable_if_scalar

using enable_if_scalar = typename std::enable_if<STD_IS_REPLACEMENT(scalar, T), T>::type

Helpers for shorter function names.

◆ enable_if_not_scalar

using enable_if_not_scalar = typename std::enable_if<!STD_IS_REPLACEMENT(scalar, T), T>::type

◆ enable_if_float

using enable_if_float = typename std::enable_if<STD_IS_REPLACEMENT(floating_point, T), T>::type

◆ enable_if_not_float

using enable_if_not_float = typename std::enable_if<!STD_IS_REPLACEMENT(floating_point, T), T>::type

◆ enable_if_integral

using enable_if_integral = typename std::enable_if<STD_IS_REPLACEMENT(integral, T), T>::type

◆ enable_if_not_integral

using enable_if_not_integral = typename std::enable_if<!STD_IS_REPLACEMENT(integral, T), T>::type

◆ VariadicInstance

using VariadicInstance = Tuple<Id, DataDictionary>

This tuple holds the information for an instance of a variadic port: The Id is the port identifier, and the DataDictionary contains additional parameters for the instance.

◆ IconProvider

using IconProvider = Delegate<Result<Url>(const CString&)>

An icon provider is queried to return a Url of an icon file (png or svg) for a given CString identifier. The identifier can stem e.g. from the NODE::BASE::ICON attribute of a node resource. To resolve such an identifier to a Url, all icon providers registered at the IconProviders registry are queried by GetUrlFromIconProviders(), and the first one which returns a non-null Url will be used.

◆ SubDataPath

using SubDataPath = BaseArray<Data>

◆ SubDataPathBlock

using SubDataPathBlock = Block<const Data>

◆ AioBuffer

using AioBuffer = BaseArray<Char>

◆ SOCKET

typedef int SOCKET

◆ ReturnResolveError

using ReturnResolveError = Result<void>

◆ SSH_CHANGE_PASSWORD_CALLBACK

using SSH_CHANGE_PASSWORD_CALLBACK = void(*)(String& newPassword)

◆ NETWORKCHAR

typedef Char NETWORKCHAR

◆ SocketT

typedef int SocketT

◆ HandleRequestDelegate

using HandleRequestDelegate = Delegate<Result<void>(const NetworkWebServerRef& server, const NetworkHttpHandlerRef& remoteConnection, const String& file, const DataDictionary& request)>

◆ IndexSelectionType

using IndexSelectionType = RangeSet<UInt32, BurstTrieMapSelector<4, 20> >

◆ IndexSelection

using IndexSelection = StrongCOWRef<IndexSelectionType>

◆ WeakNimbusBaseRef

using WeakNimbusBaseRef = WeakRef<NimbusBaseRef>

◆ FunctionRegistration

using FunctionRegistration = Delegate<Result<void>(py::NativePyCFunctionWithKeywords func)>

◆ NativePyCFunctionTable

using NativePyCFunctionTable = Tuple<const Char*, py::NativePyCFunctionWithKeywords>

◆ PyChar

using PyChar = Char

◆ FilterProgressMonitorFunction

using FilterProgressMonitorFunction = Bool (*)(void* userPtr, Float progress)

◆ CFAutoReference

using CFAutoReference = CFStrongRef<T>

compatibility: Use CFStrongRef

◆ NSAutoReference

using NSAutoReference = NSStrongRef<T>

compatibility: Use NSStrongRef

◆ GridAccessorBase

using GridAccessorBase = GridAccessorRef<Generic>

◆ VolumeRayIntersectorBase

using VolumeRayIntersectorBase = VolumeRayIntersectorRef<Generic>

◆ DelegatePointObjectsPair

using DelegatePointObjectsPair = Pair<Delegate<Result<void>(void*, PointsToVolumeListRef&)>, BaseArray<void*> >

◆ DelegatePointObjectsPairList

using DelegatePointObjectsPairList = BaseArray<DelegatePointObjectsPair>

Enumeration Type Documentation

◆ COMMAND_ASSET_STATE

enum COMMAND_ASSET_STATE
strong
Enumerator
NONE 
ENABLED 
CHECKED 
HIDDEN 
HAS_OPTIONS 

◆ ASSETLICENSETYPE

enum ASSETLICENSETYPE : UInt64
strong
Enumerator
NONE 
ENABLE_IN_SUBSCRIPTION 
SHOW_IN_SUBSCRIPTION 
ENABLE_IN_PERPETUAL 
SHOW_IN_PERPETUAL 
ENABLE_IN_TRIAL 
SHOW_IN_TRIAL 
ENABLE_IN_LITE 
SHOW_IN_LITE 
ENABLE_IN_STUDENT 
SHOW_IN_STUDENT 
ENABLE_IN_EDUCATION 
SHOW_IN_EDUCATION 
ENABLE_IN_CINEWARE 
SHOW_IN_CINEWARE 
ONLY_IN_MAXONONE 
ENABLE_IN_ALL 
SHOW_IN_ALL 
ALLBITS 

◆ ASSET_FIND_MODE

enum ASSET_FIND_MODE
strong

The flags of ASSET_FIND_MODE control the behavior of AssetRepositoryInterface::FindAssets.

Enumerator
NONE 

No flag set.

LATEST 

Set this flag to obtain only the latest version of the asset.

ALL 

Set this flag to obtain all versions of the asset.

WITHOUT_BASES 

Set this flag if the asset shouldn't be looked up in base repositories.

WITH_DELETED 

Set this flag to also find deleted assets.

PREFIX 

Set this flag to include assets for which the given identifier is a prefix of their identifier.

RANDOMIZED_ORDER 

Set this flag when you want to get assets in randomized order, this is useful for parallelized code.

CHECK_CANCELLATION 

Set this flag when you want to check if the job is cancelled. if cancelled a OperationCancelledError is returned.

PRIVATE_QUERY_REPOSITORY_VISIBILITY 

Private: if this flag is given then the delegate is called at the beginning of each findasset if the repository, the const AssetDescription& points to a const AssetRespsitoryRef&.

◆ REPOSITORYINDEXSTATE

enum REPOSITORYINDEXSTATE
strong
Enumerator
NONE 
PENDING 
RUNNING 
EXISTS 

◆ OUTPUTLOCATION

enum OUTPUTLOCATION
strong
Enumerator
BETA 
C4D 
NET 
ALL 

◆ ASSETINSERTOBJECTMODE

enum ASSETINSERTOBJECTMODE
strong

used as parameter in AssetCreationInterface::CreateObjectsOnDrag()

Enumerator
ASOBJECT 

create new assets as an individual object

ASINSTANCE 

if one object of the same object was already dragged into the scene create a instance

ASRENDERINSTANCE 

if one object of the same object was already dragged into the scene create a render instance

ASXREF 

if one object of the same object was already dragged into the scene create a legacy xref

◆ GENERATESCENEPREVIEWIMAGEFLAGS

enum GENERATESCENEPREVIEWIMAGEFLAGS
strong
Enumerator
NONE 
ISORIGINALDOCUMENT 

if set the document will be cloned for rendering, otherwise the document will be used and modified directly.

FRAMESCENE 

frames the scene before rendering

PREVIEWRENDER 

use the preview renderer instead of the selected render engine

GEOMETRYONLY 

apply geometry only rendering to the scene (in case of PREVIEWRENDER)

AUTODETECT_RENDERENGINE 

detect render engine from document

◆ OPENSAVEASSETDIALOGFLAGS

enum OPENSAVEASSETDIALOGFLAGS
strong
Enumerator
NONE 
ALLOW_EDIT_ID 

enabled the editfield of the assset id to allow the user editing of the id.

ALLOW_EDIT_NAME 

allows to edit the name of the asset

SHOW_VERSION 

shows the version edit field to let the user enter a version name

ALLOW_EMPTY_CATEGORY 

set to allow to clear the category (make it blank). otherwise the user needs to choose a category.

SHOW_MAKE_DEFAULT 

enabled the "make as default" checkbox for presets.

◆ ASSETPOPUPOPTIONS

enum ASSETPOPUPOPTIONS
strong
Enumerator
NONE 
POPUPMODE 

opens the manager in popup mode

MODAL 

opens a modal dialog

EXECUTELOAD 

in POPUPMODE mode do not call the resultCallback, but execute the load on doubleclick directly

ALLOWDRAGANDDROP 

enables d&d out of the manager

ALLOWPINPOPUP 

show pin button to make dialog sticky

SHOWCATEGORIESONLY 

special mode to select only categories

SHOWKEYWORDSONLY 

special mode to select only keywords

SHOWCATEGORYLIST 

enables the category list for selections

SHOWQUICKTABS 

enables the visibility of the quicktabs

DISPLAYASLIST 

displays the popup as list instead of gridview

HIDEWATCHFOLDERS 

Hides Watchfolder categories.

COMMANDER 

@markprivate

◆ MASTERFILTER

enum MASTERFILTER
strong
Enumerator
ALL 

Filter for all types.

OBJECTS 

Filter for object assets only.

MATERIALS 

Filter for material assets only.

MEDIA 

Filter for media assets only.

NODES 

Filter for node assets only.

SCENE_NODES 

Filter for scene nodes only.

SCENES 

Filter for scene files only.

PRESETS 

Filter for presets only.

SPECIAL 

Filter for special mode.

◆ COMMANDSTATE

enum COMMANDSTATE
strong

Defines if a command can be executed or not.

Enumerator
DISABLED 

The command can't be executed.

ENABLED 

The command can be executed.

◆ COMMANDRESULT

enum COMMANDRESULT
strong

Defines the result of the command after execution.

Enumerator
OK 

The command was executed properly.

SKIP 

The command did not execute because no action was necessary (e.g. no selection).

BREAK 

The command execution was interrupted.

◆ INTERACTIONTYPE

enum INTERACTIONTYPE
strong

Defines the interactivity mode.

Enumerator
NONE 

No interaction.

START 

Interaction start (e.g. first mouse click).

ITERATE 

Interaction iteration, performed several times after START (e.g. mouse drag).

END 

Interaction end (e.g. mouse released).

REALTIME 

Real-time iterative interaction (e.g. cursor over viewport).

◆ MOVE_MODE

enum MOVE_MODE
strong
Enumerator
KEEP_SOURCE 
DESTRUCT_SOURCE 

◆ NO_MATCH_TYPE

enum NO_MATCH_TYPE
strong
Enumerator
VALUE 

◆ VALUEKIND

enum VALUEKIND : UInt64
strong

This enum is used for DataType as a classification of the kind of values which the DataType represents. Actual values are composed of several flags.

Enumerator
NONE 
VOID_TYPE 

The data type represents the void type.

GENERIC 

The data type represents the Generic type.

GENERIC_ARITHMETIC 

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

SCALAR 

The type is a scalar type.

INTEGRAL 

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

FLOATING_POINT 

The type is a floating point type.

ENUM 

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

DATA 

The data type is Data.

DATAPTR 

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

NONVIRTUAL_INTERFACE 

The data type is a non-virtual interface.

VIRTUAL_INTERFACE 

The data type consists of a set of virtual interfaces.

REF_OR_POINTER 

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

POINTER 

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

STRONG_REFERENCE 

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

COW_REFERENCE 

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

UNIQUE_REFERENCE 

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

ACOW_REFERENCE 

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

LV_REFERENCE 

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

RV_REFERENCE 

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

TUPLE 

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

STRUCT 

The data type has an underlying TupleDataType with named members.

SIMD 

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

BLOCK 

The data type is a Block.

STRIDED_BLOCK 

The data type is a strided Block.

BASEARRAY 

The data type is a BaseArray type.

BLOCKARRAY 

The data type is a BlockArray type.

RESULT 

The data type is a Result.

DELEGATE 

The type is a DelegateDataType.

FUNCTION 

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

CONST_QUALIFIED 

The type is const-qualified.

SOURCE_LEVEL 

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

DEEP_CONSTNESS 

The data type obeys deep constness.

INT_SIZE_OR_LESS 

Values of the data type fit into an Int.

ZERO_INITIALIZED 

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

ORDERED 

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

TRIVIALLY_CONSTRUCTIBLE 

Values of the data type are trivially constructible.

TRIVIALLY_DESTRUCTIBLE 

Values of the data type are trivially destructible.

TRIVIALLY_COPYABLE 

Values of the data type are trivially copyable.

TRIVIALLY_EQUATABLE 

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

TRIVIALLY_HASHABLE 

Values of the data type are trivially hashable (see IsTriviallyHashable).

OBJECT_REF 

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

VALUE 

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

ELEMENT_TYPE_AS_ARG 

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

NEVER_NULLPTR 

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

SIGNED 

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

GENERIC_INSTANTIATION 

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

ABSTRACT 

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

NAMED 

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

CONTAINER_REF 

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

GENERIC_CONTAINER 

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

RECURSIVE_CONTAINER 

The data type represents a recursive container type.

RESOLVED_RECURSIVE_CONTAINER 

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

CONTAINER 

The data type is a ContainerDataType.

EMPTY_CONTAINER 

The data type is a ContainerDataType.

VIRTUAL_TUPLE_CONTAINER 

The data type is a ContainerDataType.

STATIC_ARRAY_CONTAINER 

The data type is a ContainerDataType.

ARRAY_CONTAINER 

The data type is a ContainerDataType.

ARRAY 

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

CONTAINER_MASK 

The data type is a ContainerDataType.

NAMED_TUPLE 

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

CONTAINS_RECURSIVE_CONTAINER 

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

CONTAINS_INVALID_TYPE 

The data type directly or indirectly contains the InvalidType.

BUNDLE 

The data type is a bundle type.

MIN_DERIVED_CONTAINER 
MIN_ARRAY_CONTAINER 
MAX_ARRAY_CONTAINER 
COW_MASK 

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

STRONG_MASK 

Test mask to check for reference counting semantics.

PTR_MASK 

Test mask any kind of pointer/reference.

CONTAINER_OR_REF 
REFERENCE_MASK 
ARITHMETIC_MASK 

Test mask for concrete arithmetic types.

TUPLE_MASK 
TUPLE_INHERIT_MASK 
POINTER_FLAGS 

The VALUEKIND of a pointer.

QUALIFIER_MASK 
CONTAINS_MASK 

◆ COLLECTION_KIND

enum COLLECTION_KIND
strong

Possible kinds of a collection.

See also
GetCollectionKind
Enumerator
NONE 

Not a collection.

ARRAY 

The collection is an array.

SET 

The collection is a set.

MAP 

The collection is a map.

◆ BYTEORDER

enum BYTEORDER
strong

The byte order of data type which is longer than one byte. You can use SYSTEM_BYTEORDER to determine the current system byte order.

Enumerator
BIG 

Big Endian Format, used on Motorola and IBM Processors (e.g. PowerPC)

LITTLE 

Little Endian Format, used on Intel and ARM Processors.

◆ CONFIGURATION_CATEGORY

enum CONFIGURATION_CATEGORY
strong

Help Category for configuration values.

Enumerator
REGULAR 

Help will be shown when application is started with command line parameter help. Use this value for configuration variables that are relevant to an end-user.

DEVELOPMENT 

Help will be shown when application is started with command line parameter help=dev. Use this value for configuration variables that are relevant to a developer.

MODULE 

Help will be shown when application is started with command line parameter help=module. Don't use this for your own variables.

EXTENSION 

Help will be shown when application is started with command line parameter help=extension. Don't use this for your own variables.

IMPLEMENTATION 

Help will be shown when application is started with command line parameter help=impl. Don't use this for your own variables.

NONE 

No help will be shown.

SUBSCRIBER 

This entry jjust copies whatever setting has been assigned to the owner.

◆ CONFIGURATIONENTRY_ORIGIN

enum CONFIGURATIONENTRY_ORIGIN
strong

Source where a configuration value was defined.

Enumerator
APPLICATION 

Configuration value was defined by the application itself.

CONFIGURATION 

Configuration value originated from a configuration file.

ENVIRONMENT 

Configuration value originated from an environment variable.

COMMANDLINE 

Configuration value originated from a command line parameter.

◆ CONFIGURATIONENTRY_STATE

enum CONFIGURATIONENTRY_STATE
strong

State of a configuration value.

Enumerator
UNUSED 

Configuration value was not used by or known to the application. This is e.g. true for environment variables that the application cannot process.

INVALIDARGUMENT 

Configuration value was recognized by the application, but argument was invalid.

USED 

Configuration value was recognized and successfully used by the application.

OUTOFRANGE 

Configuration value was recognized by the application, but argument was out of range. The value has been clamped and is now valid.

◆ CONDITIONTOKENTYPE

enum CONDITIONTOKENTYPE
strong

Condition token types extracted by DataDescriptionUIInterface::TokenizeCondition.

Enumerator
NONE 
ATTRIBUTEID 
DYN_ATTRIBUTEID 

Identifier for which DataDescriptionDefinitionInterface::GetDataValueOrDefaults will be called.

VARIABLE 

Same as ATTRIBUTEID but the attribute is animated, this makes the whole condition bypassed as true.

CONSTANT 

External variable, see DataDescriptionDefinitionInterface::EvaluateCondition.

FUNCTION 

Constant value for comparison.

OPERATOR 

A function call.

PARENTHESIS 

Comparison operator, logic operator, this token often contains constants and parenthesis.

◆ GETDATAFLAGS

enum GETDATAFLAGS
strong

Flags used in combination with GetDataCallbackType.

Enumerator
NONE 

no flags

INTENT_ENABLING 

Set this flag to get the effective value for the enabling with out port links (but the effective coming from the linked port)

INTENT_ENABLING_ISCONNECTED 

Check only if the property is connected.

INTENT_ENABLING_GRAPHNODE 

Return the GraphNode of the property.

INTENT_ENABLING_HASVALUE 

Same as INTENT_ENABLING, but limited to value, will not return a type when no value is present.

INTENT_GET_TRANSLATEDCHILDREN 

Fetch TRANSLATEDCHILDREN attribute from a port's EffectivePortDescription.

◆ DBVERSION

enum DBVERSION
strong

used in FixDatabaseProps.

Enumerator
S22 
R23_CONVERTLIMIT 

convert limit Bool to enum

R23_CONVERTENUM 

convert .enum and .command. to #enum and #command#

R23_CONVERTENUM2 

convert .enum and .command. fixes ITEM#328085 [RE] Strings Translation tool deletes already translated strings

R23_DBVERSIONIDTYPE 

removes the old dbversion type

CURRENT 

◆ DESCRIPTIONMESSAGECHECKFLAGS

enum DESCRIPTIONMESSAGECHECKFLAGS
strong

used in DescriptionMessageCheck.

Enumerator
NONE 

no flags

ENABLED 

menu entry should be enable.

VISIBLE 

visible menu entry is visible

CHECKED 

menu entry is checked with a check mark symbol.

SORTSUBMENU 

true to sort sub menu entries

◆ LOADDESCRIPTIONMODE

enum LOADDESCRIPTIONMODE
strong
Enumerator
COMPLETE 

returns the complete description

OVERWRITTEN 

returns the data description editor description with overwritten parameters.

◆ PREPAREHELPERFLAGS

enum PREPAREHELPERFLAGS
strong

Flags to describe the properties of I/O helper classes.

Enumerator
NONE 
INITIALIZE_READ 

The helper's ReadAction will get a call with INITIALIZEHASH before the class has been read.

INITIALIZE_WRITE 

The helper's WriteAction will get a call with INITIALIZEHASH before the class has been written.

FINALIZE_READ 

The helper's ReadAction will get a call with FINALIZEHASH after the class has been read.

FINALIZE_WRITE 

The helper's WriteAction will get a call with FINALIZEHASH after the class has been written.

VALIDATE_STATE 

The helper's ReadAction will get a call after all input operations are finished. Objects that interact with others can then update necessary information.

◆ DATATYPEBUILDERNAME

enum DATATYPEBUILDERNAME
strong
Enumerator
HUMAN_READABLE 
CODE_CPP 

◆ DAYOFWEEK

enum DAYOFWEEK
strong

Day of Week.

Enumerator
MONDAY 

Monday.

TUESDAY 

Tuesday.

WEDNESDAY 

Wednesday.

THURSDAY 

Thursday.

FRIDAY 

Friday.

SATURDAY 

Saturday.

SUNDAY 

Sunday.

◆ DST

enum DST : Int16
strong

Daylight Saving Time information.

Enumerator
AUTOMATIC 

When a date-time object gets converted the Daylight Saving Time is automatically detected and added.

NOTSET 

When a date-time object gets converted the Daylight Saving Time is not added to the target time.

SET 

When a date-time object gets converted the Daylight Saving Time is added to the target time.

◆ JULIANDATE

enum JULIANDATE
strong

Variants of Julian Day.

Enumerator
STANDARD 

Standard variant with epoch of 12h Jan 1, 4713 BC.

REDUCED 

Reduced JD with epoch of 12h Nov 16, 1858.

MODIFIED 

Modified variant with epoch of 0h Nov 17, 1858.

LEGACY 

Legacy mode with Julian Day + 0.5.

TRUNCATED 

Truncated variant with epoch of 0h May 24, 1968.

DUBLIN 

Dublin variant with epoch of 12h Dec 31, 1899.

LILIAN 

Lilian variant with epoch of Oct 15, 1582[9].

RATEDIE 

Rate Die variant with epoch of Jan 1, 1, proleptic Gregorian calendar.

UNIXTIME 

Unix Time variant with epoch of 0h Jan 1, 1970.

MARSSOL 

Mars Sol Date variant with epoch of 12h Dec 29, 1873.

◆ HARDWAREBREAKPOINTTYPE

enum HARDWAREBREAKPOINTTYPE
strong

Hardware breakpoint type.

Enumerator
CODE 

Throws an exception when the program counter touches the code at the watch address.

READWRITE 

Throws an exception when the watched memory will be read or written.

WRITE 

Throws an exception when the watched memory will be written.

◆ HARDWAREBREAKPOINTSIZE

enum HARDWAREBREAKPOINTSIZE
strong

Hardware breakpoint size.

Enumerator
SIZE1 

1 byte.

SIZE2 

2 bytes.

SIZE4 

4 bytes.

SIZE8 

8 bytes.

◆ FILEFORMATDETECTIONFLAGS

enum FILEFORMATDETECTIONFLAGS
strong
Enumerator
NONE 
FASTDETECTION 

perform a faster detection when scanning many files (e.g. check suffixes before running real identification code for windows media foundation movies files because windows needs 500 ms for each)

◆ FILEFORMAT_PRIORITY

enum FILEFORMAT_PRIORITY
strong

FILEFORMAT_PRIORITY defines the priority order of file formats. The lower the value the later it will be called.

Enumerator
SHIFT_ONE 

Add/Sub this value to in/decrease the priority by 1.

SHIFT_TEN 

Add/sub this value to in/decrease the priority by 10.

FALLBACKFORMAT 

Specifies the lowest priority of a file format.

GENERALFORMAT 

Specifies the medium priority of a file format. This should be used for general loaders which handle many formats through other APIS (e.g. ffmpeg)

NATIVEFORMAT 

Specifies the highest priority of a file format. This should be used for native implementations (e.g. image formats like jpg, tif done by us).

◆ ASSET_UPDATE_POLICY

enum ASSET_UPDATE_POLICY
strong

ASSET_UPDATE_POLICY controls how the referenced asset of an AssetLink is updated when a newer version of the asset exists.

Enumerator
NEVER 

The asset is never updated, so the link always points to the exact version recorded in the link.

EXPLICIT 

The asset isn't updated implicitly, but the user is asked if the link shall point to the latest version if there is a newer version than the one recorded in the link.

IMPLICIT 

The asset is updated implicitly whenever a newer version of the asset exists.

◆ IOTIMEMODE

enum IOTIMEMODE
strong

Requested IoTime.

Enumerator
CREATED 

Creation time of files/directories.

MODIFIED 

Modification time of files/directories.

ACCESSED 

Last access time of files/directories.

◆ URLCOMPARE

enum URLCOMPARE
strong

Flag to pass to Compare.

Enumerator
DEFAULT 

Default comparison mode. Urls are case-sensitive.

NORMALIZE 

Normalizes both operands (via Normalize) before the links are compared with URLCOMPARE::DEFAULT.

IONORMALIZE 

Normalizes both operands (via IoNormalize) before the links are compared with URLCOMPARE::DEFAULT.

LEGACY 

Activates legacy behavior like in C4D which does case-insensitive comparison on Windows and OS X (but not Linux).

FULL 

DEFAULT + compare with all data dictionaries.

◆ IODETECT

enum IODETECT
strong

Return value of IoDetect().

Enumerator
ERRORSTATE 

Error code, e.g. IoHandlerInterface not found.

NONEXISTENT 

Url doesn't exist.

UNKNOWN 

Url is of unknown type.

FILE 

Url is a file.

LINK 

Url is a link.

DIRECTORY 

Url is a directory, you can use GetBrowseIterator to iterate through the children.

◆ OPENSTREAMFLAGS

enum OPENSTREAMFLAGS
strong

Flags for Url::OpenInputStream(), Url::OpenOutputStream(), Url::OpenInOutputStream()

Enumerator
NONE 

No flags set.

WRITE_DONT_TRUNCATE 

Allows to write to existing files without truncation, so the existing file is kept as is.

ALLOW_SHARED_READ_WRITE_ACCESS 

Allows other threads to read / write the file in parallel. The other instance needs to set this flag also. If you open a file for writing WRITE_DONT_TRUNCATE must be specified at the same time. There are certain limitations under OS X and Linux, see FileLocks.

SEEK_TO_END 

Sets the file handle to the end of file after opening. To append to the end of a file use WRITE_DONT_TRUNCATE | SEEK_TO_END.

FULL_DUPLEX 

Allows to open streams (tcp) using full duplex where data can be read and sent simultaneously.

ASK_FOR_REMOVE_WRITE_PROTECTION 

If the file that should be written is write protected the system will ask for checkout/remove flags.

◆ NORMALIZEFLAGS

enum NORMALIZEFLAGS
strong

Flags for Url::Normalize and Url::IoNormalize.

Enumerator
NONE 

Just used for internal purposes. Has no effect when used on a resolve function.

SCHEME_BASED 

If given the scheme decides on his own how the path is resolved. Exclusive flag.

CASE 

The path is put to the canonical form (preferred is lowercase). A given authority is untouched.

PATH_SEGMENT 

Removes . and .. in case they are full path segments.

UNICODE_DECOMPOSITION 

Normalization for unicode decompositions. Only used by OSX file handler, ignored by other implementations and OS.

UNDERLYING 

Resolve Url to underlying Url if possible for 1 level. E.g., an asset Url might get resolved to a file Url.

UNDERLYING_RECURSIVE 

Resolve Url to underlying Url if possible recursive for all levels. E.g., an asset Url might get resolved to a file Url.

◆ IOATTRIBUTES

enum IOATTRIBUTES : UInt
strong

Attributes of Url.

Enumerator
NONE 
READONLY 

Url is read only.

HIDDEN 

Url is hidden.

ARCHIVE 

Url has archive bit set.

LOCKED 

Url is locked (only for Mac, ignored on Windows).

OWNER_R 

Url RWX flags (osx/linux).

OWNER_W 

Url RWX flags (osx/linux).

OWNER_X 

Url RWX flags (osx/linux).

GROUP_R 

Url RWX flags (osx/linux).

GROUP_W 

Url RWX flags (osx/linux).

GROUP_X 

Url RWX flags (osx/linux).

PUBLIC_R 

Url RWX flags (osx/linux).

PUBLIC_W 

Url RWX flags (osx/linux).

PUBLIC_X 

Url RWX flags (osx/linux).

RW_MASK 

Url RW mask (osx/linux).

RWX_MASK 

Url RWX mask (osx/linux).

MASK_ALL 

Masks all attributes, e.g. IoSetAttributes(IoGetAttributes(),IOATTRIBUTES::MASK_ALL).

◆ IOSHOWINOSFLAGS

enum IOSHOWINOSFLAGS
strong

Flags used by Url::IoShowInOS and IoConnection::IoShowInOS.

Enumerator
NONE 

No flags.

SHOW_IN_EXPLORER 

Show the url in the windows explorer or osx finder.

OPEN_IN_EXPLORER 

Open the file using the connected app in the operating system.

◆ MACHINESTATE

enum MACHINESTATE
strong

State of a MachineRef. Various scenarios are possible with connected machines. a) A machine is manually added but also announced via ZeroConf services. b) A machine is added by ZeroConf and established a connection, but afterwards the ZeroConf disappeared and the connection is still online.

Enumerator
NONE 

No bit set.

CONNECTION_ERROR 

A connection error occurred with the machine.

ADDED_MANUALLY 

Flag that signals that the machine is added manually.

AVAILABLE_ZEROCONF 

Flag that signals that the machine is announced via zeroconf and is currently online (not necessary connected).

CONNECTED 

Flag that signals that the machine is currently connected to the local machine.

ALL 

All Flags combined, useful for masking.

◆ NULL_RETURN_REASON

enum NULL_RETURN_REASON
strong
Enumerator
NULLPTR 
MAKE_WRITABLE_FAILED 
UNRESOLVED 
NULLIMPL 

◆ NO_VALUE_TYPE

enum NO_VALUE_TYPE
strong

Dummy value to indicate that there is no value.

Enumerator
VALUE 

◆ PARSERFLAGS

enum PARSERFLAGS
strong
Enumerator
NONE 
HAS_NO_EOF 

◆ ACCESSLEVEL

enum ACCESSLEVEL
strong
Enumerator
UNDEFINED 

not defined, invalid setting.

USERINSTALLATION 

settings for this users local installation.

ACCOUNT 

settings for the currently logged-in user.

USER 

settings for the current local user.

MACHINE 

settings for all users of the current machine.

DEFAULTS 

settings of the default value (needs to be initialized on startup)

ALL 

start level of the search through all instances USERINSTALLATION -> ACCOUNT -> USER -> MACHINE -> DEFAULT

◆ EXECUTEPROGRAMFLAGS

enum EXECUTEPROGRAMFLAGS
strong
See also
SystemProcessInterface::StartProcess().
Enumerator
NONE 
CAPTURELOGFILE 

The standard output will be routed into a file.

DONT_DELETE_LOGFILE 

The logfile will not be deleted at the end of the call.

HIDE_APPLICATION 

Starts the application in hidden mode (e.g. suppresses the console window when running under windows).

◆ EXECUTEPROGRAMCALLBACK

enum EXECUTEPROGRAMCALLBACK
strong
See also
SystemProcessInterface::StartProcessAndWait().
Enumerator
STARTED 

Program started regular.

RUNNING 

Program is running, this callback comes every second. return 0 to continue. return 'stop' to kill the running process.

FINISHED 

Program finish.

KILLED 

Program finish with signal kill.

CLEANUP_OK 

Cleanup phase (succeeded case), here the logfile should be deleted!

CLEANUP_FAILED 

Cleanup phase (failed case), here the logfile should be deleted!

◆ WAIT_PROCESS_RESULT

enum WAIT_PROCESS_RESULT
strong

Result of WaitForProcess.

Enumerator
FINISHED 

Process has finished.

RUNNING 

Process is still running.

◆ THREADPRIORITY

enum THREADPRIORITY : Int16
strong
Enumerator
NORMAL 
ABOVE 
BELOW 
LOWEST 
BACKGROUND_IDLE 

◆ WAITMODE

enum WAITMODE
strong

WAITMODE can be optionally specified for almost all objects with a Wait() method. Most of the time you don't have to specify anything and implicitely use the default. You can however specify WAITMODE::RETURN_ON_CANCEL in cases where your job/thread might be cancelled and you don't want it to hang in a Wait() call.

{
// ... your job/ thread code doing something ...
// wait for something (could be a job, thread, group, condition variable ...)
if (something.Wait(TIMEVALUE_INFINITE, WAITMODE::RETURN_ON_CANCEL) == false)
{
// At this point Wait() has returned even though something we waited for has not completed.
// We might have to cancel something for (e.g. if it depends on data owned by this job)
// and wait until it has done so. This looks like the following:
something.Cancel();
// Now wait until it has really cancelled (does not access our data anymore).
something.Wait();
}
// Here you might release whatever data you owned which something was accessing.
}
maxon::TIMEVALUE_INFINITE
static const TimeValue TIMEVALUE_INFINITE
Definition: timevalue.h:460
maxon::WAITMODE::RETURN_ON_CANCEL
@ RETURN_ON_CANCEL
Wait() should return if the caller has been cancelled even though the condition is not set yet.
Enumerator
DEFAULT 

Default case: Wait() will return if the condition is set or it has timed out.

RETURN_ON_CANCEL 

Wait() should return if the caller has been cancelled even though the condition is not set yet.

PRIVATE_BLOCKING 

Wait() won't execute other jobs on the thread while it is waiting (for legacy threads only).

EXTERNAL_ENQUEUE 

Wait() for a job which has been enqueued by a different thread (by default this is not allowed to prevent deadlocks).

DONT_WAIT 

For ExecuteOnMainThread only: Do not wait.

◆ THREADTYPE

enum THREADTYPE
strong
Enumerator
MAIN 

The main thread.

WORKER 

A worker thread of a queue.

STANDALONE 

A standalone thread.

ALIEN 

An alien thread (only limited use of MAXON API allowed).

ASSIMILATED 

An assimilated alien thread (full use of the MAXON API allowed).

◆ BASE_DIMENSION

enum BASE_DIMENSION
strong
Enumerator
LENGTH 
TIME 
MASS 
TEMPERATURE 
AMOUNT_OF_SUBSTANCE 
ELECTRIC_CURRENT 
LUMINOUS_INTENSITY 
ANGLE 
SOLID_ANGLE 
PRIVATE_COUNT 

◆ URLFILECACHEFLAGS

enum URLFILECACHEFLAGS
strong

Flags used by UrlFileCacheInterface::FindOrCreateUrl.

Enumerator
NONE 
FORCE_RELOAD 

Reloads the file from the sourceUrl, a new cache file will be created. The previous cache file will stay until older UrlFileCacheEntries disappear.

◆ ERROR_OK

enum ERROR_OK
strong

A single-valued enum to indicate success of an operation. This is used for comparisons with Result, and for an Error constructor.

Enumerator
VALUE 

The single value of this enum.

◆ ERROR_FAILED

enum ERROR_FAILED
strong

A single-valued enum to indicate failure of an operation. This is used for comparisons with Result.

Enumerator
VALUE 

The single value of this enum.

◆ ERROR_TYPE

enum ERROR_TYPE
strong

This enum is used for CreateError() to indicate the desired error class.

Enumerator
OUT_OF_MEMORY 

Create an OutOfMemoryError.

NULLPTR 

Create a NullptrError.

ILLEGAL_ARGUMENT 

Create an IllegalArgumentError.

ILLEGAL_STATE 

Create an IllegalStateError.

NOT_IMPLEMENTED 

Create a FunctionNotImplementedError.

UNRESOLVED 

Create an UnresolvedError.

UNKNOWN 

Create an UnknownError.

◆ GEOMETRY_TEST_EXACT

enum GEOMETRY_TEST_EXACT
strong

Return type for geometric tests when degenerate cases need to be reported.

Enumerator
GEOM_FALSE 

Test result is false.

GEOM_TRUE 

Test result is true.

GEOM_PARALLEL 

Degenerate colinear, ordered in same direction.

GEOM_ANTIPARALLEL 

Degenerate colinear, ordered in opposite direction.

GEOM_COINCIDENT_PREV 

Degenerate coincident points.

GEOM_COINCIDENT_NEXT 

Degenerate coincident points.

GEOM_COINCIDENT_ALL 

Degenerate coincident points.

GEOM_DEGENERATE 

Other degeneracy.

GEOM_INVALID_INPUT 

Input is non-valid in some way making it impossible to proceed.

◆ LOOP_OVERLAP_STATE

enum LOOP_OVERLAP_STATE
strong

Return type for loop overlap state queries.

Enumerator
INTERSECTING 

Loops intersect each other. Contact points do not count as intersections, only actual crossings of the loops.

DISJOINT 

Loops are completely disjoint from each other.

A_INSIDE_B 

A is entirely within B.

B_INSIDE_A 

B is entirely within A.

COINCIDENT 

Loops are coincident - they lie on each other's perimeter, e.g. A and B are the same.

DEGENERATE 

At least one of A and B has insufficient vertices (need at least 3)

◆ GRAPH_TYPE

enum GRAPH_TYPE
strong

Define graph type.

Enumerator
CONTINUOS 

The Graph is continuos so all points in array list order.

SPARSE 

The Graph is sparse so points have to be sorted before modeling.

◆ WIRE_MODE

enum WIRE_MODE : UChar
strong

WIRE_MODE is used for the wires in a Wires object to control whether a wire is set, inherited or hidden.

This is an ordered enumeration with NONE < MIN < NORMAL < MAX. Other values shouldn't be used for ordered comparisons.

See also
Wires
Enumerator
NONE 

No wire.

MIN 

A wire with minimum priority.

NORMAL 

A wire with normal priority.

PROPAGATION 

A wire with propagation priority.

AUTO_PROPAGATION 

A wire with auto-propagation priority.

MAX 

A wire with maximum priority.

REMOVE 

Only used for MutablePort::Connect to tell that the an existing wire shall be removed.

ALL 

A mask for all explicit modes.

FLAG0 

A wire flag which can be used for wires which don't interpret the wire mode as priority, but as a bit set. Different from NORMAL and any other flag in WIRE_MODE.

FLAG1 

A wire flag which can be used for wires which don't interpret the wire mode as priority, but as a bit set. Different from NORMAL and any other flag in WIRE_MODE.

IMPLICIT 

Used as mask for implicit wires in MutablePort::GetConnections.

ALL_INCLUDING_IMPLICIT 

A mask for all modes.

INHERIT 

Used for MutablePort::Connect to tell that the wire mode shall be inherited. (Also used internally.)

FLAGS_MASK 

Mask for FLAG0 | FLAG1.

FULL_MASK 

Complete mask for all bits of WIRE_MODE.

CONNECT_DEFAULT 

Default mode for Connect methods.

GETCONNECTIONS_DEFAULT 

Default mode for GetConnections methods.

◆ CONNECTION_POSITION

enum CONNECTION_POSITION
strong

Graph connections can store attribute values at three different positions: At their source, at their center and at their target.

Enumerator
SOURCE 

The source position of a connection.

CENTER 

The center position of a connection.

TARGET 

The target position of a connection.

◆ NODE_KIND

enum NODE_KIND
strong

NODE_KIND allows to determine whether a general node (g-node for short) is a true node, a port or a port list. Because nodes, ports and port lists can be represented in a single hierarchy, classes such as GraphNode and GNode make use of this and need NODE_KIND to determine the actual kind of a g-node.

  • NODE stands for true nodes. They may contain nested nodes and two port lists, one for the input ports and one for the output ports.
  • INPUTS and OUTPUTS stand for port lists. They occur in the hierarchy as direct children of true nodes. Each true node may have at most one input list and one output list.
  • INPORT and OUTPORT stand for ports. When a port is actually a port bundle, it may contain nested ports. A port is a child of either a port bundle or a port list.
Enumerator
NONE 

Special value used e.g. for null references.

NODE 

Indicates that the g-node is a true node.

INPUTS 

Indicates that the g-node is an input port list. An input port list has a true node as parent and input ports as children.

OUTPUTS 

Indicates that the g-node is an output port list. An output port list has a true node as parent and output ports as children.

INPORT 

Indicates that the g-node is an input port. An input port has an input port list or an input port as parent and input ports as children.

OUTPORT 

Indicates that the g-node is an output port. An output port has a output port list or a output port as parent and output ports as children.

IN_MASK 

Mask to check a NODE_KIND if it stands for an input port or an input port list.

OUT_MASK 

Mask to check a NODE_KIND if it stands for an output port or an output port list.

PORTLIST_MASK 

Mask to check a NODE_KIND if it stands for a port list.

PORT_MASK 

Mask to check a NODE_KIND if it stands for a port.

ALL_MASK 

Mask which matches all node kinds.

◆ COLORPROFILEINFO

enum COLORPROFILEINFO
strong

Return value of ColorProfile.GetInfo() function.

Enumerator
DESCRIPTION 

Description of the color profile.

MANUFACTURER 

Manufacturer of the color profile.

MODEL 

Model of the color profile.

COPYRIGHT 

Copyright information of the color profile.

NAME 

Name of the color profile.

OCIO_CONFIG_PATH 

Full path to the OCIO config file (empty if this is not an OCIO colorspace)

◆ COLORCONVERSIONINTENT

enum COLORCONVERSIONINTENT
strong

Color Conversion intent. This value controls the intent of the color conversion. Members docs copied from http://www.littlecms.com/LittleCMS2.6%20tutorial.pdf

Enumerator
PERCEPTUAL 

Hue hopefully maintained (but not required), lightness and saturation sacrificed to maintain the perceived color. White point changed to result in neutral grays. Intended for images.

RELATIVE_COLORIMETRIC 

Within and outside gamut; same as Absolute Colorimetric. White point changed to result in neutral grays.

SATURATION 

Hue and saturation maintained with lightnesssacrificed to maintain saturation. White point changed to result in neutral grays. Intended for business graphics (make it colorful charts, graphs, overheads, ...)

ABSOLUTE_COLORIMETRIC 

Within the destination device gamut; hue, lightness and saturation are maintained. Outside the gamut; hue and lightness are maintained, saturation is sacrificed. White point for source and destination; unchanged. Intended for spot colors (Pantone, TruMatch, logo colors, ...)

◆ COLORCONVERSIONFLAGS

enum COLORCONVERSIONFLAGS
strong

Color Conversion intent. This value controls the intent of the color conversion. Members docs copied from http://www.littlecms.com/LittleCMS2.6%20tutorial.pdf

Enumerator
NONE 
BLACKPOINTCOMPENSATION 

Black Point Compensation (BPC) controls whether to adjust for differences in black points when converting colors between color spaces. When Black Point Compensation is enabled, color transforms map white to white and luminance of black to luminance of black. The black point compensation feature does work better in conjunction with relative colorimetric intent. Perceptual intent should make no difference, although it may affect some (wrong) profiles.

INVERSE_DIRECTION 

◆ LAYERSETMODE

enum LAYERSETMODE
strong
Enumerator
LAYERS 

Layers / layer Sets.

LAYERMASKS 

Layer masks.

ALPHAS 

Alpha channels.

LAYERALPHA 

Layer alpha.

DISABLED 

Disabled.

◆ MEDIAFORMATTYPE

enum MEDIAFORMATTYPE
strong

MEDIAFORMAT::IMAGE::TYPE specifies the meaning of the stream.

Enumerator
UNDEFINED 

Must never happen! This value should not be used and should never appear.

IMAGE 

This is the image resource of the stream. This could be the only one in the stream.

ALPHA 

Declares the stream to be interpreted as the alpha channel of the parent stream. This stream must be inserted under a MEDIAFORMATTYPE::IMAGE.

LAYERFOLDER 

Declares the stream to be interpreted as a group layer of the parent stream. This stream must be inserted under a MEDIAFORMATTYPE::IMAGE or another MEDIAFORMATTYPE::LAYERFOLDER.

LAYER 

Declares the stream to be interpreted as a layer of the parent stream. This stream must be inserted under a MEDIAFORMATTYPE::IMAGE or another MEDIAFORMATTYPE::LAYERGROUP.

LAYERADJUSTMENT 

Declares the stream to be interpreted as a adjustment layer of the parent stream. This stream must be inserted under a MEDIAFORMATTYPE::IMAGE or another MEDIAFORMATTYPE::LAYERFOLDER.

LAYERMASK 

Declares the stream to be interpreted as a layer mask of the parent stream. This stream must be inserted under a MEDIAFORMATTYPE::LAYER, MEDIAFORMATTYPE::LAYERADJUSTMENT or MEDIAFORMATTYPE::LAYERFOLDER.

MIPMAP 

Declares the stream to be interpreted as mipmap of the parent stream. This stream must be inserted under a MEDIAFORMATTYPE::IMAGE.

DEEPIMAGEDATA 

Declares the stream to be interpreted as a deep image data. This stream must be inserted under a MEDIAFORMATTYPE::IMAGE.

◆ MEDIAALPHATYPE

enum MEDIAALPHATYPE
strong

MEDIAFORMAT::IMAGE::ALPHATYPE specifies the meaning of the stream.

Enumerator
UNDEFINED 

Undefined.

PREMULTIPLIED 

The alpha is related to premultiplied rgb data.

STRAIGHT 

The alpha is related to straight rgb data.

◆ RLACHANNELS

enum RLACHANNELS
strong
Enumerator
Z 
MATERIALID 
NODE_ID 
UV 
NORMAL 
REALPIX 
COVERAGE 
BG 
NODE_RENDER_ID 
COLOR 
TRANSP 
VELOC 
WEIGHT 
MASK 
MAXCOUNT 

◆ RLAFLAGS

enum RLAFLAGS
strong
Enumerator
NONE 

None.

Z 

Z.

MATERIALID 

MATERIALID.

OBJECTBUFFER 

Object buffer.

UV 

UV coordinates.

NORMAL 

Normals.

ORIGCOLOR 

Non-clamped color.

COVERAGE 

Coverage.

BG 

BG.

OBJECTID 

Object ID.

COLOR 

Color.

TRANSPARENCY 

Transparency.

SUBPIXEL_WEIGHT 

Sub-pixel weight.

SUBPIXEL_MASK 

Sub-pixel mask.

◆ SELECTIONHANDLERRESULT

enum SELECTIONHANDLERRESULT
strong

Result type of the MediaOutputSelectionHandler.

Enumerator
NONE 
STRUCTURE 

load the image structure (e.g. layers, folders) but create only the layers.

CONTENT_FLAG 

load the image/layer data.

STRUCTURE_WITH_CONTENT 

load the image structure and load the image/layer data.

ALL 

load all (e.g. like no filter would be set).

◆ MEDIASESSIONFLAGS

enum MEDIASESSIONFLAGS
strong
Enumerator
NONE 
RUNONLYANALYZE 

run only the analyze but not the execute pass.

FORCELOAD 

loads the image even if it's already loaded.

◆ BLEND_MODES

enum BLEND_MODES
strong
Enumerator
ADD 
AVERAGE 
COLOR 
COLORBURN 
COLORDODGE 
DARKEN 
DARKER 
DIFFERENCE 
DISSOLVE 
DIVIDE 
EXCLUSION 
FREEZE 
GLOW 
HARDLIGHT 
HARDMIX 
HEAT 
HUE 
HYPOT 
LEVR 
LIGHTEN 
LIGHTER 
LINEARBURN 
LINEARDODGE 
LUMINANCE 
MULTIPLY 
OVER 
OVERLAY 
PINLIGHT 
REFLECT 
SATURATION 
SCREEN 
SOFTLIGHT 
SUBTRACT 
VIVIDLIGHT 
XOR 
PASSFOLDER 
STAMP 

◆ ANIMBLENDSTATE

enum ANIMBLENDSTATE
strong

Parameter used in the ObservableAnimation of the BlendTweenInterface.

Enumerator
NONE 
STARTED 

Optional signal that the animation started. This flags arrives only if duration is != 0.

RUNNING 

Optional signal that the animation is running within some in between state.

FINISHED 

Signals that the animation reached the final state, this state is guaranteed.

CANCELED 

The Animation has been canceled.

◆ FFT_FLAGS

enum FFT_FLAGS
strong

Flags for the FFT transform.

Enumerator
NONE 
CALC_INVERSE 

If set, the reverse transformation from frequency domain to time domain is computed.

SUPPRESS_PADDING 

Suppress automatic padding. Note: Most implementations run faster if the input array count is even or a power of 2. But padding changes the output array count and fills the remaning array entries with zeros. This leads to a slightly different output since padding with zeros in the time domain effectively means interpolating in the frequency domain. For some critical applications it might be advisable to leave the original array size intact. Works only if the implementation supports this feature, otherwise the flag is ignored.

◆ FFT_SUPPORT

enum FFT_SUPPORT
strong

Flags for GetSupportOptions()

Enumerator
NONE 
TRANSFORM_1D 

Component supports 1D transformation.

TRANSFORM_2D 

Component supports 2D transformation.

ALWAYS_PADDING 

If set component always does padding of the input array (e.g. power of 2).

◆ NURBSCURVE_CONTINUITY

enum NURBSCURVE_CONTINUITY
strong
Enumerator
OPEN 

Open spline with No continuity between first and last point.

CLOSED 

Closed spline with position continuity (sharp cusp) between first and last point. Replaces any previous knot vector with a clamped uniform knot vector.

PERIODIC 

Closed spline with C2 continuity between first and last point. Replaces any previous knot vector with an unclamped uniform knot vector.

◆ NURBSCURVE_KNOTMODE

enum NURBSCURVE_KNOTMODE
strong
Enumerator
CLAMPED_UNIFORM 

Clamped uniform (open uniform / quasi uniform) NURBS/B-Spline/Bezier knot vector with end knots of multiplicity of degree. Internal knots are uniform e.g. [0, 0, 0, 1/3, 2/3, 1, 1, 1]. If there are no internal knots then the spline is equal to a bezier spline of same degree e.g. [0, 0, 0, 0, 1, 1, 1, 1].

CLAMPED_CHORDAL 

Clamped nonuniform knot vector whose inner knots are computed according to the actual position of control points in space according to the chord length method. Works only correct if SetPoints has been called before since the routines needs to compute the point distances.

CLAMPED_CENTRIPETAL 

Clamped nonuniform knot vector whose inner knots are computed according to the actual position of control points in space according to the centripetal method.Works only correct if SetPoints has been called before since the routines needs to compute the point distances.

UNCLAMPED_UNIFORM 

uniform knot vector e.g. [0.0, 0.25, 0.5, 0.75, 1.0]. Mostly useful for periodic (closed) splines

USER_DEFINED 

Arbitrary knot vector, supplied by the user.

◆ PRIMITIVETYPE

enum PRIMITIVETYPE
strong
Enumerator
NONE 
POINT 
EDGE 
POLYGON 

◆ CORENODE_PORT_FLAGS

enum CORENODE_PORT_FLAGS
strong

PORT_FLAGS indicates the status of each port of a CoreNode when invoking it with parameters. Some ports can be unconnected, we have to pass proper flags so the node knows which inputs are supplied and which outputs are needed.

Enumerator
NONE 
INPUT_WITHOUT_VALUE 
OUTPUT_UNUSED 

◆ PORT_DIR

enum PORT_DIR : Int
strong

PORT_DIR indicates the kind of a port or the direction of a connection:

  • PORT_DIR::INPUT stands for an input port or an incoming connection (from a source).
  • PORT_DIR::OUTPUT stands for an output port or an outgoing connection (to a target).

To support loops over those two directions, there are the special values BEGIN and END:

for (PORT_DIR dir = PORT_DIR::BEGIN; dir != PORT_DIR::END; ++dir)
{
}
maxon::PORT_DIR
PORT_DIR
Definition: graph_basics.h:34
maxon::PORT_DIR::BEGIN
@ BEGIN
The start value (inclusive) for a loop over port directions.
maxon::PORT_DIR::END
@ END
The end value (exclusive) for a loop over port directions.
Enumerator
INPUT 

Input direction, i.e., an input port or an incoming connection.

OUTPUT 

Output direction, i.e., an output port or an outgoing connection.

BEGIN 

The start value (inclusive) for a loop over port directions.

END 

The end value (exclusive) for a loop over port directions.

◆ IOFORMAT

enum IOFORMAT
strong
Enumerator
DEFAULT 
BINARY 
BINARY_COMPRESSED 
JSON 
XML 
JSON_STABLE 

This format is identical to JSON but resolves all references on writing and sorts sets and maps so the order stays stable. JSON_STABLE does not support writing of WeakRefs to COW objects.

◆ PROFILER_POINT_TYPE

enum PROFILER_POINT_TYPE
strong

Internal. Defines the type of a profiling point.

Enumerator
NONE 

Unspecified.

METHOD_ENTER 

Enter Method Scope.

METHOD_LEAVE 

Leave Method Scope.

SCOPE_ENTER 

Enter Scope.

SCOPE_LEAVE 

Leave Scope.

DELTA 

Delta From Last Visited Point.

◆ PROFILER_STATE

enum PROFILER_STATE
strong

Internal. Defines the profiler state.

Enumerator
DISABLED 

Disabled.

ENABLED_METHOD_SCOPE 

Enabled for METHOD_ENTER and METHOD_LEAVE point types.

ENABLED_ALL 

Enabled for all point types.

◆ PROFILER_CLOCK_MODE

enum PROFILER_CLOCK_MODE
strong

Internal. Defines the profiler clock mode.

Enumerator
NORMAL 

Use the system clock.

SIMULATED 

Use a simulated clock for profiling purpose.

◆ SELECTION_MODE

enum SELECTION_MODE : UChar
strong

Selection Modifier.

Enumerator
NEW 

new selection - needs reset of all previously existing selections

ADD 

add to selection

SUBTRACT 

subtract selection

TOGGLE 

toggle selection

◆ SELECTION_STATUS

enum SELECTION_STATUS : UChar
strong

Selection status.

Enumerator
NONE 

no selection at all

SELECTED 

item (e.g. widget/presenter) is selected

IMPLICIT 

item (e.g. widget/presenter) is implicitly selected

◆ HTTPCODE

enum HTTPCODE
strong

Return codes for http functions.

Enumerator
CLOSED 

the connection has been closed.

FINISHED 

the request has been completed.

CALL_NEXT_HANDLER 

the request was not processed by this message handler, continue with the next one.

PROXYERROR 

a proxy configuration error

OK 

return a http okay.

POST 

return a http post.

MOVED 

"301 Moved Permanently". the requested file has been moved. check the header "location" entry to get the new location.

SYNTAX 

return a http syntax error.

AUTH 

return a http authentication error.

ACCESS 

return a http access error.

NOTFOUND 

return a http file not found error.

PROXYAUTHENTICATIONREQUIRED 

a connection requires proxy authentication

INTERNAL 

return a http internal error.

UNKNOWN 

return a http unknown error.

GATEWAYTIMEOUT 

return a http gateway timeout error.

◆ SOCKETMODE

enum SOCKETMODE
strong
Enumerator
READ 
WRITE 
LISTEN 
CONNECT 

◆ CONNECTIONMODE

enum CONNECTIONMODE
strong
Enumerator
UNDEFINED 
SEND 
READ 

◆ CONNECTIONTYPE

enum CONNECTIONTYPE
strong
Enumerator
LISTENER 
INCOMING 
OUTGOING 

◆ PROTOCOL

enum PROTOCOL
strong

Defines the type of an IP address used by NetworkIpAddrInterface.

Enumerator
UNSPEC 

Unspecified.

IPV4 

IPV4 address.

IPV6 

IPV6 address.

◆ WILDCARD_IPV4_ADDRESS_TYPE

enum WILDCARD_IPV4_ADDRESS_TYPE
strong

Any IPv4 address. Equivalent to INADDR_ANY.

Enumerator
VALUE 

◆ WILDCARD_IPV6_ADDRESS_TYPE

enum WILDCARD_IPV6_ADDRESS_TYPE
strong

Any IPv6 address. Equivalent to in6addr_any.

Enumerator
VALUE 

◆ SSLSOCKETTYPE

enum SSLSOCKETTYPE
strong
Enumerator
CLIENTCONNECTION 
SERVERCONNECTION 

◆ SSLPROTOCOLVERSION

enum SSLPROTOCOLVERSION
strong

Defines possible ssl protocol versions.

Enumerator
TLS1 

use TLS1.

TLS11 

use TLS1.1.

TLS12 

use TLS1.2.

TLS 

use newest TLS version.

◆ SSLCERTREQUIREMENTS

enum SSLCERTREQUIREMENTS
strong

Defines possible ssl certificate verification options.

Enumerator
NONE 

mode: no certificate is required.

ISOPTIONAL 

mode: a certificate is optional. If this flag is set you need to deliver a valid caCertsFile file in the SSLNetworkConnectionInterface::Init() function.

ISREQUIRED 

mode: a server certificate is required and need to have a valid ca root. If this flag is set you need to deliver a valid caCertsFile file in the SSLNetworkConnectionInterface::Init() function.

MODE 
VERIFY_AUTHORITY 

flag: verifies the server certificate with the given url. if the server authority pattern doesn't match an error is returned in the handshake.

◆ SSLFILETYPE

enum SSLFILETYPE
strong
Enumerator
ASN1 
PEM 

◆ OAUTHSIGNATUREMETHOD

enum OAUTHSIGNATUREMETHOD
strong
Enumerator
NONE 
PLAINTEXT 
HMAC_SHA1 

◆ OAUTHHTTPMETHOD

enum OAUTHHTTPMETHOD
strong
Enumerator
NONE 
GET 
POST 

◆ OAUTHERRORCODE

enum OAUTHERRORCODE
strong
Enumerator
NO_USERACCOUNT 
SERVICE_NOT_AVAILABLE 

◆ HTTPMETHOD

enum HTTPMETHOD
strong
Enumerator
GET 
POST 
PUT 
DELETE 

◆ HTTPREQUESTTYPE

enum HTTPREQUESTTYPE
strong
Enumerator
UNKNOWN 
GET 
POST 

◆ WEBSOCKETSTATE

enum WEBSOCKETSTATE
strong
Enumerator
NOT_CONNECTED 

connection is not established yet.

CONNECTED 

connection is established.

CLOSED 

connection is closed. Sending data is not allowed anymore.

ERROR 

connection is in error state, so it's going to be closed.

◆ WEBSOCKETTYPE

enum WEBSOCKETTYPE
strong

Used by NetworkWebSocketConnectionInterface::Send().

Enumerator
TEXT 

text WebSocket frame.

BINARY 

binary WebSocket frame.

CLOSE 

◆ WEBSOCKET_OPCODE

enum WEBSOCKET_OPCODE : UChar
strong

WebSockets opcodes. See https://tools.ietf.org/html/rfc6455 for details.

Enumerator
CONTINUE 

continuation frame, no data follows

TEXT 

text frame

DATA 

binary frame

CLOSE 

closing frame

PING 

ping frame

PONG 

pong frame

ILLEGAL 

invalid state

◆ ZEROCONFACTION

enum ZEROCONFACTION
strong
Enumerator
NONE 
RESOLVE 
MONITOR 

◆ ZEROCONFMACHINESTATE

enum ZEROCONFMACHINESTATE
strong
Enumerator
ONLINE 
OFFLINE 
REMOVED 
UPDATE 

◆ ZEROCONFERROR

enum ZEROCONFERROR
strong
Enumerator
NONE 
UNKNOWN 
NOSUCHNAME 
NOMEMORY 
BADPARAM 
BADREFERENCE 
BADSTATE 
BADFLAGS 
UNSUPPORTED 
NOTINITIALIZED 
ALREADYREGISTERED 
NAMECONFLICT 
INVALID 
FIREWALL 
INCOMPATIBLE 
BADINTERFACEINDEX 
REFUSED 
NOSUCHRECORD 
NOAUTH 
NOSUCHKEY 
NATTRAVERSAL 
DOUBLENAT 
BADTIME 
BADSIGNAL 
BADKEY 
TRANSIENT 
SERVICENOTRUNNING 
NATPORTMAPPINGUNSUPPORTED 
NATPORTMAPPINGDISABLED 
NOROUTER 
POLLINGMODE 

◆ NIMBUS_PATH

enum NIMBUS_PATH
strong

NIMBUS_PATH is used as argument for NimbusBaseInterface::GetPath and NimbusBaseInterface::SetPath.

Enumerator
STARTNODE 

Path of the node initially shown in the Attributes Manager.

SOLO 

Path of the node or port used for solo mode.

MATERIALENDNODE 

Path of the material end node.

◆ PyStringEncodings

enum PyStringEncodings
strong
Enumerator
Utf8 
Utf16 
Utf32 
PyDecode 

◆ OWNERSHIP

enum OWNERSHIP
strong
Enumerator
NORMAL 
CALLER 

Default ownership.

CALLEE 

Caller owns the object.

CALLER_BUT_COPY 

Callee owns the object.

◆ Errno

enum Errno : int
strong
Enumerator
_EPERM 
_ENOENT 
_ESRCH 
_EINTR 
_EIO 
_ENXIO 
_E2BIG 
_ENOEXEC 
_EBADF 
_ECHILD 
_EAGAIN 
_ENOMEM 
_EACCES 
_EFAULT 
_ENOTBLK 
_EBUSY 
_EEXIST 
_EXDEV 
_ENODEV 
_ENOTDIR 
_EISDIR 
_EINVAL 
_ENFILE 
_EMFILE 
_ENOTTY 
_ETXTBSY 
_EFBIG 
_ENOSPC 
_ESPIPE 
_EROFS 
_EMLINK 
_EPIPE 
_EDOM 
_ERANGE 
_EDEADLK 
_ENAMETOOLONG 
_ENOLCK 
_ENOSYS 
_ENOTEMPTY 
_ELOOP 
_EWOULDBLOCK 
_ENOMSG 
_EIDRM 
_ECHRNG 
_EL2NSYNC 
_EL3HLT 
_EL3RST 
_ELNRNG 
_EUNATCH 
_ENOCSI 
_EL2HLT 
_EBADE 
_EBADR 
_EXFULL 
_ENOANO 
_EBADRQC 
_EBADSLT 
_EDEADLOCK 
_EBFONT 
_ENOSTR 
_ENODATA 
_ETIME 
_ENOSR 
_ENONET 
_ENOPKG 
_EREMOTE 
_ENOLINK 
_EADV 
_ESRMNT 
_ECOMM 
_EPROTO 
_EMULTIHOP 
_EDOTDOT 
_EBADMSG 
_EOVERFLOW 
_ENOTUNIQ 
_EBADFD 
_EREMCHG 
_ELIBACC 
_ELIBBAD 
_ELIBSCN 
_ELIBMAX 
_ELIBEXEC 
_EILSEQ 
_ERESTART 
_ESTRPIPE 
_EUSERS 
_ENOTSOCK 
_EDESTADDRREQ 
_EMSGSIZE 
_EPROTOTYPE 
_ENOPROTOOPT 
_EPROTONOSUPPORT 
_ESOCKTNOSUPPORT 
_EOPNOTSUPP 
_EPFNOSUPPORT 
_EAFNOSUPPORT 
_EADDRINUSE 
_EADDRNOTAVAIL 
_ENETDOWN 
_ENETUNREACH 
_ENETRESET 
_ECONNABORTED 
_ECONNRESET 
_ENOBUFS 
_EISCONN 
_ENOTCONN 
_ESHUTDOWN 
_ETOOMANYREFS 
_ETIMEDOUT 
_ECONNREFUSED 
_EHOSTDOWN 
_EHOSTUNREACH 
_EALREADY 
_EINPROGRESS 
_ESTALE 
_EUCLEAN 
_ENOTNAM 
_ENAVAIL 
_EISNAM 
_EREMOTEIO 
_EDQUOT 
_ENOMEDIUM 
_EMEDIUMTYPE 
_ECANCELED 
_ENOKEY 
_EKEYEXPIRED 
_EKEYREVOKED 
_EKEYREJECTED 
_EOWNERDEAD 
_ENOTRECOVERABLE 

◆ CONTAINS

enum CONTAINS : int
strong
Enumerator
_FOUND 
_NOTFOUND 
_ERROR 

◆ VMSETTINGS

enum VMSETTINGS
strong
Enumerator
MOVE_ERRORS_TO_RESULT 
USE_AUTO_GIL 

◆ VMINITSETTINGS

enum VMINITSETTINGS
strong
Enumerator
CPYTHON_ADDITIONAL_SYS_PATH 

maxon::Url

CPYTHON_INTERPRETERFLAGS 

py::PYTHONFLAG

CPYTHON_SUBINTERPRETER 

Bool.

PYPY_EXECUTABLE 

Private.

◆ ERRORHANDLING

enum ERRORHANDLING
strong
Enumerator
PRINT 

Any thrown exception will be handled internally.

CLEAR 

Any thrown exception will be cleared automatically.

REDIRECT 

Any thrown exception will result in a corresponding maxon.Error. The internal error state of the virtual machine is untouched.

◆ DEFAULTRUNTIME

enum DEFAULTRUNTIME
strong
Enumerator
NONE 
DEBUG_3_VS2015 
RELEASE_3_VS2015 
DEBUG_3 
RELEASE_3 
DEFAULT_3 
DEFAULT 

◆ VOLUMESAMPLER

enum VOLUMESAMPLER
strong
Enumerator
NEAREST 
LINEAR 
QUADRATIC 

◆ ITERATORTYPE

enum ITERATORTYPE
strong
Enumerator
ALL 
ON 
OFF 

◆ TREEVOXELLEVEL

enum TREEVOXELLEVEL
strong
Enumerator
ROOT 
TWO 
THREE 
LEAF 

◆ VOLUME_RAY_TYPE

enum VOLUME_RAY_TYPE
strong
Enumerator
WORLD_SPACE 

world space

INDEX_SPACE 

index space

◆ POLYGONCONVERSIONFLAGS

enum POLYGONCONVERSIONFLAGS
strong
Enumerator
NONE 
UNSIGNED_DISTANCE_FIELD 
DISABLE_INTERSECTING_VOXEL_REMOVAL 
DISABLE_RENORMALIZATION 
DISABLE_NARROW_BAND_TRIMMING 

◆ MIXVECTORTYPE

enum MIXVECTORTYPE
strong
Enumerator
NONE 
NORMAL 
ADD 
SUBTRACT 
CROSS 

◆ SDFFILTERTYPE

enum SDFFILTERTYPE
strong
Enumerator
NONE 
GAUSSIAN 
DILATE 
ERODE 
MEANVALUE 
MEDIANVALUE 
MEANCURVATURE 
LAPLACIANFLOW 
RENORMALIZE 
OPEN 
CLOSE 
TRACK 
RESIZE 

◆ FILTERTYPE

enum FILTERTYPE
strong
Enumerator
NONE 
GAUSSIAN 
MEANVALUE 
MEDIANVALUE 
ADD 
REMAP 
CURVEREMAP 
MULTIPLY 
ABS 
INVERT 

◆ VECTORFILTERTYPE

enum VECTORFILTERTYPE
strong
Enumerator
NONE 
GAUSSIAN 
MEANVALUE 
MEDIANVALUE 
CURL 
NORMALIZE 
INVERT 
SCALE 
ROTATE 

◆ FILTERACCURACY

enum FILTERACCURACY
strong
Enumerator
NONE 
FIRST 
SECOND 
THIRD 
WENO5 
HJWENO5 

◆ RESAMPLEINTERPOLATIONTYPE

enum RESAMPLEINTERPOLATIONTYPE
strong
Enumerator
NONE 
NEAREST 
LINEAR 
QUADRATIC 

Function Documentation

◆ MAXON_REGISTRY() [1/60]

maxon::MAXON_REGISTRY ( Class< AutoWeightRef >  ,
AutoWeightAlgos  ,
"net.maxon.animation.registry.autoweights"   
)

◆ MAXON_ENUM_FLAGS() [1/33]

enum maxon::COMMAND_ASSET_STATE maxon::MAXON_ENUM_FLAGS ( COMMAND_ASSET_STATE  )

◆ MAXON_DATATYPE() [1/66]

maxon::MAXON_DATATYPE ( AssetDatabaseStruct  ,
"net.maxon.datatype.assetdatabasestruct"   
)

◆ MAXON_DATATYPE() [2/66]

maxon::MAXON_DATATYPE ( DragAndDropDataAssetArray  ,
"net.maxon.datatype.draganddropdataassetarray"   
)

◆ MAXON_FORWARD() [1/2]

class DataDescription maxon::MAXON_FORWARD ( "maxon/datadescription.h"  )

◆ MAXON_FORWARD() [2/2]

class DataDescriptionDefinition MAXON_FORWARD ( "maxon/datadescriptiondefinition.h"  )

◆ MAXON_ENUM_FLAGS() [2/33]

enum maxon::ASSETLICENSETYPE UInt64 maxon::MAXON_ENUM_FLAGS ( ASSETLICENSETYPE  )

◆ MAXON_DATATYPE() [3/66]

maxon::MAXON_DATATYPE ( AssetDependencyStruct  ,
"net.maxon.datatype.asset.dependencystruct"   
)

◆ MAXON_DECLARATION() [1/84]

maxon::MAXON_DECLARATION ( Class< AssetType >  ,
AssetTypeBaseComponent  ,
"net.maxon.component.assettypebase"   
)

This base component can be used by implementations of AssetType.

◆ MAXON_REGISTRY() [2/60]

maxon::MAXON_REGISTRY ( AssetType  ,
AssetTypes  ,
"net.maxon.registry.assettypes"   
)

The registry for asset types.

See also
AssetType

◆ MAXON_ENUM_FLAGS() [3/33]

enum maxon::ASSET_FIND_MODE maxon::MAXON_ENUM_FLAGS ( ASSET_FIND_MODE  )

◆ MAXON_DECLARATION() [2/84]

maxon::MAXON_DECLARATION ( ComponentDescriptor  ,
AssetBaseComponent  ,
"net.maxon.component.assetbase"   
)

This base component can be used by implementations of Asset.

◆ MAXON_ENUM_LIST() [1/95]

enum maxon::REPOSITORYINDEXSTATE maxon::MAXON_ENUM_LIST ( REPOSITORYINDEXSTATE  )

◆ MAXON_REGISTRY() [3/60]

maxon::MAXON_REGISTRY ( BuiltinAssetLoader  ,
BuiltinAssetLoaders  ,
"net.maxon.registry.builtinassetloaders"   
)

The built-in asset repository uses this registry to find built-in assets. When its FindAssets method is invoked it forwards the call to each of the registered loaders.

◆ MAXON_REGISTRY() [4/60]

maxon::MAXON_REGISTRY ( Class< AssetRepositoryRef >  ,
AssetRepositoryTypes  ,
"net.maxon.registry.assetrepositorytypes"   
)

◆ MAXON_DECLARATION() [3/84]

maxon::MAXON_DECLARATION ( Class< AssetRepositoryRef >  ,
AssetRepositoryDecoratorBaseClass  ,
"net.maxon.class.assetrepositorydecoratorbase"   
)

A base implementation class for a decorator of AssetRepositoryRef. You can use this class as base class whenever you implement such a decorator. The class forwards calls of all methods of AssetRepositoryInterface to the decorated object.

◆ MAXON_DECLARATION() [4/84]

maxon::MAXON_DECLARATION ( Class< AssetRepositoryRef >  ,
WeakAssetRepositoryDecoratorClass  ,
"net.maxon.class.weakassetrepositorydecorator"   
)

An implementation class for a decorator of AssetRepositoryRef where the decorated repository is held by a weak reference. The class forwards calls of all methods of AssetRepositoryInterface to the decorated object.

◆ GetAssetUrl()

Url maxon::GetAssetUrl ( const DndAsset &  asset)

GetAssetUrl returns the url of a DndAsset.

Parameters
[in]assetDrag&Drop asset to check.
Returns
Url on success.

◆ UpdateAssetUsage()

Result<void> maxon::UpdateAssetUsage ( const AssetDescription &  asset,
Bool  incCount = true,
Bool  updateDate = true 
)

Mark the asset as used and increment the usage counter. This function will update the ASSETMETADATA::Uage meta data by increasing the count and date

Parameters
[in]assetAsset to mark.
[in]incCountTrue to update the count.
[in]updateDateTrue to update the usage count.
Returns
OK on success.

◆ IdToIdAndVersion()

Result<IdAndVersion> maxon::IdToIdAndVersion ( const Id &  id)

IdToIdAndVersion helper function to convert a compacted id back to an id and version.

Parameters
[in]idCompacted id.
Returns
Extracted Id and version on success.

◆ IdAndVersionToId()

Result<Id> maxon::IdAndVersionToId ( const IdAndVersion &  assetId)

IdAndVersionToId compacts an IdAndVersion into a id.

Parameters
[in]assetIdId to compact.
Returns
Id on success.

◆ IdToIdAndVersionWithRepository()

Result<Tuple<AssetRepositoryRef, IdAndVersion, Bool> > maxon::IdToIdAndVersionWithRepository ( const Id &  id,
const AssetRepositoryRef &  lookupRepository 
)

IdToIdAndVersionWithRepository calls IdToIdAndVersion and adds the repository ontop.

Parameters
[in]idId to extract.
[in]lookupRepositoryRepository to look at.
Returns
Tuple<AssetRepositoryRef, IdAndVersion, Bool> on success. Bool: limitRepository

◆ IdAndVersionToIdWithRepository()

Result<Id> maxon::IdAndVersionToIdWithRepository ( const IdAndVersion &  assetId,
const AssetRepositoryRef &  repository 
)

IdAndVersionToIdWithRepository inverse of IdToIdAndVersionWithRepository.

Parameters
[in]assetIdAssetId to compact.
[in]repositoryRepository to use.
Returns
OK on success.

◆ MAXON_DATATYPE() [4/66]

maxon::MAXON_DATATYPE ( StoreAssetStruct  ,
"net.maxon.datatype.storeassetstruct"   
)

◆ MAXON_DATATYPE() [5/66]

maxon::MAXON_DATATYPE ( ResolveAssetDependenciesStruct  ,
"net.maxon.datatype.resolveassetdependenciesstruct"   
)

◆ MAXON_DATATYPE() [6/66]

maxon::MAXON_DATATYPE ( AddAssetDepencendyStruct  ,
"net.maxon.datatype.addassetdepencendystruct"   
)

◆ MAXON_DECLARATION() [5/84]

maxon::MAXON_DECLARATION ( Class< BasePresetAssetType >  ,
AssetTypeBasePresetClass  ,
"net.maxon.class.assettypepresetbase"   
)

This base component can be used by implementations of AssetType.

◆ MAXON_ATTRIBUTE() [1/12]

maxon::MAXON_ATTRIBUTE ( void  ,
AssetCategoryUncategorized  ,
"net.maxon.assetcategory.uncategorized"   
)

Uncategorized Category. This is a default category where all assets with no category ends up.

◆ MAXON_ATTRIBUTE() [2/12]

maxon::MAXON_ATTRIBUTE ( void  ,
AssetCategoryWatchFolders  ,
"category@5846c0689c0248cfa54bffed866571ce"   
)

Special Category to collect all watch folders (S26)

◆ GetDerivedMetaData()

Result<T> maxon::GetDerivedMetaData ( const AssetDescription &  asset,
const InternedId &  metaId,
const CString &  externalStamp,
CALLBACK &&  callback 
)

Caches and returns meta data which is derived from the asset via the given callback. This helper function checks if there already exists derived meta data for the identifier #metaId with matching stamp. If so, this data is loaded if necessary and returned, otherwise {callback(asset)} is called, its result is stored (to a persistent storage) as derived meta data of the asset under @metaId and finally returned.

Both the externalStamp and the value of the meta data attribute ASSETMETADATA::DerivedMetaDataStamp are taken into account for the stamp. These two stamps are stored together with the actual data, this allows for a simple mechanism to see whether the cached data is still valid. For example if the derivation requires data from some external source, you could provide the hash code of that data as externalStamp. Then, whenever that external source changes, the cached data is considered invalid. Or, to invalidate all cached derived data of an asset, you could change the value of ASSETMETADATA::DerivedMetaDataStamp.

Derived meta data of an asset is automatically invalidated whenever persistent meta data is stored for the same asset. Also all derived meta data is invalidated when the application version changes. Therefore you don't have to take this into account for the externalStamp.

Parameters
[in]assetThe asset for which derived meta data shall be obtained.
[in]metaIdThe identifier to use for the meta data.
[in]externalStampA string to tag the cached data. Only when this matches the one used for previously cached data, that data is used, otherwise the data is newly computed by the callback.
[in]callbackA callback to derived the meta data from the asset, its meta data and external data.
Returns
The derived meta data.

◆ MAXON_DECLARATION() [6/84]

maxon::MAXON_DECLARATION ( LazyLanguageStringDataDescriptionDefinition  ,
LazyLanguageStringDataDescriptionDefinitionClass  ,
"net.maxon.class.lazylanguagestringdatadescriptiondefinition"   
)

◆ MAXON_DECLARATION() [7/84]

maxon::MAXON_DECLARATION ( LazyLanguageDictionary  ,
LazyLanguageDictionaryClass  ,
"net.maxon.class.lazylanguagedictionary"   
)

◆ MAXON_ATTRIBUTE() [3/12]

maxon::MAXON_ATTRIBUTE ( void  ,
AssetCategorySmartSearch  ,
"net.maxon.asset.category.smartsearches"   
)

◆ MAXON_ENUM_FLAGS() [4/33]

enum maxon::OUTPUTLOCATION maxon::MAXON_ENUM_FLAGS ( OUTPUTLOCATION  )

◆ MAXON_ENUM_LIST() [2/95]

enum maxon::ASSETINSERTOBJECTMODE maxon::MAXON_ENUM_LIST ( ASSETINSERTOBJECTMODE  )

◆ MAXON_ENUM_FLAGS() [5/33]

enum maxon::GENERATESCENEPREVIEWIMAGEFLAGS maxon::MAXON_ENUM_FLAGS ( GENERATESCENEPREVIEWIMAGEFLAGS  )

◆ MAXON_ENUM_FLAGS() [6/33]

enum maxon::OPENSAVEASSETDIALOGFLAGS maxon::MAXON_ENUM_FLAGS ( OPENSAVEASSETDIALOGFLAGS  )

◆ MAXON_ENUM_FLAGS() [7/33]

enum maxon::ASSETPOPUPOPTIONS maxon::MAXON_ENUM_FLAGS ( ASSETPOPUPOPTIONS  )

◆ MAXON_ENUM_LIST() [3/95]

enum maxon::MASTERFILTER maxon::MAXON_ENUM_LIST ( MASTERFILTER  )

◆ MAXON_DATATYPE() [7/66]

maxon::MAXON_DATATYPE ( CommandGetStateDelegate  ,
"net.maxon.hybrid.datatype.commandgetstate"   
)

◆ MAXON_REGISTRY() [5/60]

maxon::MAXON_REGISTRY ( CommandGetStateDelegate  ,
CommandGetStateDelegates  ,
"net.maxon.hybrid.command.getstates"   
)

◆ MAXON_DATATYPE() [8/66]

maxon::MAXON_DATATYPE ( CreateMaterialWithDataDelegate  ,
"net.maxon.hybrid.datatype.creatematerialwithdatadelegate"   
)

◆ MAXON_REGISTRY() [6/60]

maxon::MAXON_REGISTRY ( CreateMaterialWithDataDelegate  ,
CreateMaterialWithDataDelegates  ,
"net.maxon.hybrid.command.creatematerialwithdata"   
)

◆ MAXON_DATATYPE() [9/66]

maxon::MAXON_DATATYPE ( CreateDefaultMaterialDelegate  ,
"net.maxon.hybrid.datatype.createdefaultmaterialdelegate"   
)

◆ MAXON_REGISTRY() [7/60]

maxon::MAXON_REGISTRY ( CreateDefaultMaterialDelegate  ,
CreateDefaultMaterialDelegates  ,
"net.maxon.hybrid.command.createdefaultmaterials"   
)

◆ GetPyElemFromNode()

Result<PythonElementBaseRef> maxon::GetPyElemFromNode ( FactoryInterface::ConstPtr  factory,
BaseList2D *  bl 
)

◆ MAXON_DECLARATION() [8/84]

maxon::MAXON_DECLARATION ( Class< PythonElementBaseRef >  ,
PythonElementBaseClass  ,
"net.maxon.class.python_element.base"   
)

◆ MAXON_DECLARATION() [9/84]

maxon::MAXON_DECLARATION ( PyBaseElementFactoryType  ,
PyBaseElementFactory  ,
"net.maxon.factory.python_element.base"   
)

◆ MAXON_DECLARATION() [10/84]

maxon::MAXON_DECLARATION ( Class< PythonElementEmbeddedRef >  ,
PythonEmbeddedClass  ,
"net.maxon.class.python_element.embedded"   
)

◆ MAXON_DECLARATION() [11/84]

maxon::MAXON_DECLARATION ( PyEmbeddedElementFactoryType  ,
PyEmbeddedElementFactory  ,
"net.maxon.factory.python_element.embedded"   
)

◆ MAXON_DECLARATION() [12/84]

maxon::MAXON_DECLARATION ( Class< PythonElementBaseRef >  ,
PythonDirectoryClass  ,
"net.maxon.class.python_element.directory"   
)

◆ MAXON_DECLARATION() [13/84]

maxon::MAXON_DECLARATION ( PyDirectoryElementFactoryType  ,
PyDirectoryElementFactory  ,
"net.maxon.factory.python_element.directory"   
)

◆ MAXON_DECLARATION() [14/84]

maxon::MAXON_DECLARATION ( Class< PythonElementScriptRef >  ,
PythonScriptClass  ,
"net.maxon.class.python_element.script"   
)

◆ MAXON_DECLARATION() [15/84]

maxon::MAXON_DECLARATION ( PyScriptElementFactoryType  ,
PyScriptElementFactory  ,
"net.maxon.factory.python_element.script"   
)

◆ MAXON_REGISTRY() [8/60]

maxon::MAXON_REGISTRY ( Class< PythonBaseList2DDetectorRef >  ,
PyBaseList2DDetectors  ,
"net.maxon.registry.python_baselist2d_detector"   
)

◆ MAXON_DECLARATION() [16/84]

maxon::MAXON_DECLARATION ( Class< PyElementManagerRef >  ,
PyElementManager  ,
"net.maxon.py_element_manager_interface"   
)

◆ MAXON_REGISTRY() [9/60]

maxon::MAXON_REGISTRY ( UiConversion  ,
UiConversions  ,
"net.maxon.image.registry.uiconversions"   
)

◆ MAXON_ENUM_LIST() [4/95]

enum maxon::COMMANDSTATE maxon::MAXON_ENUM_LIST ( COMMANDSTATE  )

◆ MAXON_ENUM_LIST() [5/95]

enum maxon::COMMANDRESULT maxon::MAXON_ENUM_LIST ( COMMANDRESULT  )

◆ MAXON_ENUM_LIST() [6/95]

enum maxon::INTERACTIONTYPE maxon::MAXON_ENUM_LIST ( INTERACTIONTYPE  ,
"net.maxon.command.interationtype"   
)

◆ MAXON_DATATYPE() [10/66]

maxon::MAXON_DATATYPE ( CommandCacheData  ,
"net.maxon.datatype.commandcachedata"   
)

◆ MAXON_DATATYPE() [11/66]

maxon::MAXON_DATATYPE ( CommandCacheMap  ,
"net.maxon.datatype.commandcachemap"   
)

◆ MAXON_REGISTRY() [10/60]

maxon::MAXON_REGISTRY ( Class< CommandDataRef >  ,
CommandDataClasses  ,
"net.maxon.command.registry.commanddataclasses"   
)

◆ MAXON_REGISTRY() [11/60]

maxon::MAXON_REGISTRY ( Class< LegacyCommandDataRef >  ,
LegacyCommandDataClasses  ,
"net.maxon.command.registry.legacycommanddataclasses"   
)

◆ MAXON_REGISTRY() [12/60]

maxon::MAXON_REGISTRY ( CommandClass  ,
CommandClasses  ,
"net.maxon.command.registry.commandclasses"   
)

◆ MAXON_REGISTRY() [13/60]

maxon::MAXON_REGISTRY ( LegacyCommandClass  ,
LegacyCommand  ,
"net.maxon.command.registry.legacycommandclass"   
)

◆ MAXON_REGISTRY() [14/60]

maxon::MAXON_REGISTRY ( MigratedCommandClass  ,
MigratedCommand  ,
"net.maxon.command.registry.migratedcommandclass"   
)

◆ MAXON_REGISTRY() [15/60]

maxon::MAXON_REGISTRY ( CommandInteractionClass  ,
CommandInteraction  ,
"net.maxon.command.registry.commandinteractionclass"   
)

◆ MAXON_REGISTRY() [16/60]

maxon::MAXON_REGISTRY ( CommandDescriptionClass  ,
CommandDescription  ,
"net.maxon.command.registry.commanddescriptionclass"   
)

◆ MAXON_REGISTRY() [17/60]

maxon::MAXON_REGISTRY ( CommandConversionClass  ,
CommandConversionClasses  ,
"net.maxon.command.registry.commandconversionclasses"   
)

◆ MAXON_REGISTRY() [18/60]

maxon::MAXON_REGISTRY ( Class< CommandCacheRef >  ,
CommandCacheClasses  ,
"net.maxon.command.registry.commandcacheclasses"   
)

◆ MAXON_DECLARATION() [17/84]

maxon::MAXON_DECLARATION ( Class< CommandObserverRef >  ,
CommandObserverObjectClass  ,
"net.maxon.command.class.observer"   
)

◆ MAXON_DATATYPE() [12/66]

maxon::MAXON_DATATYPE ( InvocationState  ,
"net.maxon.datatype.command.invokationstate"   
)

◆ TestForBeginFunction()

std::false_type maxon::TestForBeginFunction ( OverloadRank0  )

◆ TestForEndFunction()

std::false_type maxon::TestForEndFunction ( OverloadRank0  )

◆ ConstructElements() [1/2]

auto maxon::ConstructElements ( ITERATOR  first,
SENTINEL  sentinel,
const ARGS &...  args 
) -> ITERATOR

Initializes elements of value_type type in a sequence by calling their constructor with given arguments. Cannot fail.

Parameters
[in]firstStart of uninitialized sequence, i.e. pointer to first element.
[in]sentinelSequence delimiter, i.e. pointer to one position after the last element.
[in]argsConstructor arguments.
Returns
Iterator to end of the constructed sequence.

◆ ConstructElements() [2/2]

auto maxon::ConstructElements ( ITERABLE &&  iterable,
const ARGS &...  args 
) -> decltype(begin(iterable))

Equivalent to ConstructElements(begin(iterable), end(iterable), args ...).

◆ DestructElements() [1/2]

auto maxon::DestructElements ( ITERATOR  first,
SENTINEL  sentinel 
) -> ITERATOR

Destructs elements of value_type in a sequence. Cannot fail.

Parameters
[in]firstStart of sequence, i.e. pointer to first element.
[in]sentinelSequence delimiter, i.e. pointer to one position after the last element.
Returns
Iterator to end of the destructed sequence.

◆ DestructElements() [2/2]

auto maxon::DestructElements ( ITERABLE &&  iterable) -> decltype(begin(iterable))

Equivalent to Destruct(begin(iterable), end(iterable)).

◆ Copy() [1/2]

auto maxon::Copy ( ITERATOR  first,
SENTINEL  sentinel,
DEST_ITERATOR  dest 
) -> Result<DEST_ITERATOR>

Copy-assigns elements of value_type from one sequence to another. The destination sequence is expected to contain initialized values.

This function behaves similar to std::copy, but uses maxon error handling instead of exceptions. If copying an object cannot fail, i.e. for POD-types, copy assignment is used. If copying an object can fail, i.e. because of allocations, a member function Result<void> CopyFrom(const T&) must be implemented; copying an object then happens through CopyFrom().

Parameters
[in]firstStart of source sequence, i.e. pointer to first element.
[in]sentinelSource sequence delimiter, i.e. pointer to one position after the last element.
[in]destStart of destination sequence, i.e. pointer to first element.
Returns
End of the resulting destination sequence, or error if CopyFrom() failed.

◆ Copy() [2/2]

auto maxon::Copy ( const ITERABLE &  iterable,
DEST_ITERATOR  dest 
) -> Result<DEST_ITERATOR>

Equivalent to Copy(begin(iterable), end(iterable), dest).

◆ CopyIf() [1/2]

auto maxon::CopyIf ( ITERATOR  first,
SENTINEL  sentinel,
DEST_ITERATOR  dest,
PREDICATE  pred 
) -> Result<DEST_ITERATOR>

Equivalent to Copy, but only copies elements that match the given predicate. The predicate function should have a signature equivalent to

Bool func(const ElementType&);
func
PyObject Py_tracefunc func
Definition: ceval.h:10
Parameters
[in]firstStart of source sequence, i.e. pointer to first element.
[in]sentinelSource sequence delimiter, i.e. pointer to one position after the last element.
[in]destStart of destination sequence, i.e. pointer to first element.
[in]predA unary predicate.
Returns
End of the resulting destination sequence, or error if CopyFrom() failed.

◆ CopyIf() [2/2]

auto maxon::CopyIf ( const ITERABLE &  iterable,
DEST_ITERATOR  dest,
PREDICATE  pred 
) -> Result<DEST_ITERATOR>

Equivalent to CopyIf(begin(iterable), end(iterable), dest, pred).

◆ CopyToUninitialized() [1/2]

auto maxon::CopyToUninitialized ( ITERATOR  first,
SENTINEL  sentinel,
DEST_ITERATOR  dest 
) -> Result<DEST_ITERATOR>

Copy-constructs elements of value_type from one sequence to another. The destination sequence is expected to contain uninitialized values.

See Copy for more details.

Parameters
[in]firstStart of source sequence, i.e. pointer to first element.
[in]sentinelSource sequence delimiter, i.e. pointer to one position after the last element.
[in]destStart of destination sequence, i.e. pointer to first element.
Returns
End of the resulting destination sequence, or error if CopyFrom() failed.

◆ CopyToUninitialized() [2/2]

auto maxon::CopyToUninitialized ( const ITERABLE &  iterable,
DEST_ITERATOR  dest 
) -> Result<DEST_ITERATOR>

Equivalent to CopyToUninitialized(begin(iterable), end(iterable), dest).

◆ CopyToUninitializedIf() [1/2]

auto maxon::CopyToUninitializedIf ( ITERATOR  first,
SENTINEL  sentinel,
DEST_ITERATOR  dest,
PREDICATE  pred 
) -> Result<DEST_ITERATOR>

Equivalent to CopyToUninitialized, but only copies elements that match the given predicate. The predicate function should have a signature equivalent to

Bool func(const ElementType&);
Parameters
[in]firstStart of source sequence, i.e. pointer to first element.
[in]sentinelSource sequence delimiter, i.e. pointer to one position after the last element.
[in]destStart of destination sequence, i.e. pointer to first element.
[in]predA unary predicate.
Returns
End of the resulting destination sequence, or error if CopyFrom() failed.

◆ CopyToUninitializedIf() [2/2]

auto maxon::CopyToUninitializedIf ( const ITERABLE &  iterable,
DEST_ITERATOR  dest,
PREDICATE  pred 
) -> Result<DEST_ITERATOR>

Equivalent to CopyToUninitializedIf(begin(iterable), end(iterable), dest, pred).

◆ MAXON_ENUM_LIST() [7/95]

enum maxon::MOVE_MODE maxon::MAXON_ENUM_LIST ( MOVE_MODE  )

◆ Move() [1/2]

auto maxon::Move ( ITERATOR  first,
SENTINEL  sentinel,
DEST_ITERATOR  dest 
) -> DEST_ITERATOR

Move-assigns elements of value_type from one sequence to another. The destination sequence is expected to contain initialized values. The MODE parameter controls whether the elements in the source sequence will be destructed. Cannot fail.

This function behaves similar to std::move(a, b) (from <algorithm> - not to be mistaken for the one from <utility>).

Template Parameters
MODEFlags to control the behavior of this function.
Parameters
[in]firstStart of source sequence, i.e. pointer to first element.
[in]sentinelSource sequence delimiter, i.e. pointer to one position after the last element.
[in]destStart of destination sequence, i.e. pointer to first element.
Returns
End of the resulting destination sequence.

◆ Move() [2/2]

auto maxon::Move ( ITERABLE &&  iterable,
DEST_ITERATOR  dest 
) -> DEST_ITERATOR

Equivalent to Move(begin(iterable), end(iterable), dest).

◆ MoveIf() [1/2]

auto maxon::MoveIf ( ITERATOR  first,
SENTINEL  sentinel,
DEST_ITERATOR  dest,
PREDICATE  pred 
) -> DEST_ITERATOR

Equivalent to Move, but only copies elements that match the given predicate. The predicate function should have a signature equivalent to

Bool func(const ElementType&);
Parameters
[in]firstStart of source sequence, i.e. pointer to first element.
[in]sentinelSource sequence delimiter, i.e. pointer to one position after the last element.
[in]destStart of destination sequence, i.e. pointer to first element.
[in]predA unary predicate.
Returns
End of the resulting destination sequence.

◆ MoveIf() [2/2]

auto maxon::MoveIf ( ITERABLE &&  iterable,
DEST_ITERATOR  dest,
PREDICATE  pred 
) -> DEST_ITERATOR

Equivalent to MoveIf(begin(iterable), end(iterable), dest, pred).

◆ MoveToUninitialized() [1/2]

auto maxon::MoveToUninitialized ( ITERATOR  first,
SENTINEL  sentinel,
DEST_ITERATOR  dest 
) -> DEST_ITERATOR

Move-constructs elements of value_type from one sequence to another. The destination sequence is expected to contain uninitialized values. The MODE parameter controls whether the elements in the source sequence will be destructed. Cannot fail.

This function behaves similar to std::move(a, b) (from <algorithm> - not to be mistaken for the one from <utility>).

Template Parameters
MODEFlags to control the behavior of this function.
Parameters
[in]firstStart of source sequence, i.e. pointer to first element.
[in]sentinelSource sequence delimiter, i.e. pointer to one position after the last element.
[in]destStart of destination sequence, i.e. pointer to first element.
Returns
End of the resulting destination sequence.

◆ MoveToUninitialized() [2/2]

auto maxon::MoveToUninitialized ( ITERABLE &&  iterable,
DEST_ITERATOR  dest 
) -> DEST_ITERATOR

Equivalent to MoveToUninitialized(begin(iterable), end(iterable), dest).

◆ MoveToUninitializedIf() [1/2]

auto maxon::MoveToUninitializedIf ( ITERATOR  first,
SENTINEL  sentinel,
DEST_ITERATOR  dest,
PREDICATE  pred 
) -> DEST_ITERATOR

Equivalent to MoveToUninitializedIf, but only moves elements that match the given predicate. The predicate function should have a signature equivalent to

Bool func(const ElementType&);
Parameters
[in]firstStart of source sequence, i.e. pointer to first element.
[in]sentinelSource sequence delimiter, i.e. pointer to one position after the last element.
[in]destStart of destination sequence, i.e. pointer to first element.
[in]predA unary predicate.
Returns
End of the resulting destination sequence.

◆ MoveToUninitializedIf() [2/2]

auto maxon::MoveToUninitializedIf ( ITERABLE &&  iterable,
DEST_ITERATOR  dest,
PREDICATE  pred 
) -> DEST_ITERATOR

Equivalent to MoveToUninitializedIf(begin(iterable), end(iterable), dest, pred).

◆ Fill() [1/2]

auto maxon::Fill ( ITERABLE &&  iterable,
const T &  value 
) -> decltype(begin(iterable))

Equivalent to Fill(begin(iterable), end(iterable), value).

◆ Generate() [1/2]

auto maxon::Generate ( ITERATOR  first,
SENTINEL  sentinel,
GENERATOR  gen 
) -> ITERATOR

Assigns the given value to all elements in a sequence. The sequence is expected to contain initialized data. The generator function should have a signature equivalent to

ElementType func();

This function is the equivalent to std::generate.

Parameters
[in]firstStart of sequence.
[in]sentinelSequence delimiter.
[in]genGenerator function.
Returns
End of generated sequence.

◆ Generate() [2/2]

auto maxon::Generate ( ITERABLE &&  iterable,
GENERATOR  gen 
) -> decltype(begin(iterable))

Equivalent to Generate(begin(iterable), end(iterable), gen).

◆ AllOf() [1/2]

Bool maxon::AllOf ( ITERATOR  first,
SENTINEL  sentinel,
PREDICATE  pred 
)

Returns whether the given unary predicate is true for all elements in a sequence. The predicate function should have a signature equivalent to

Bool func(const ElementType&);

This function is the equivalent to std::all_of.

Parameters
[in]firstStart of sequence.
[in]sentinelSequence delimiter.
[in]predUnary predicate function.
Returns
True if predicate was true for all elements.

◆ AllOf() [2/2]

Bool maxon::AllOf ( const ITERABLE &  iterable,
PREDICATE  pred 
)

Equivalent to AllOf(begin(iterable), end(iterable), pred).

◆ AnyOf() [1/2]

Bool maxon::AnyOf ( ITERATOR  first,
SENTINEL  sentinel,
PREDICATE  pred 
)

Returns whether the given unary predicate is true for all elements in a sequence. The predicate function should have a signature equivalent to

Bool func(const ElementType&);

This function is the equivalent to std::any_of.

Parameters
[in]firstStart of sequence.
[in]sentinelSequence delimiter.
[in]predUnary predicate function.
Returns
True if predicate was true for any element.

◆ AnyOf() [2/2]

Bool maxon::AnyOf ( const ITERABLE &  iterable,
PREDICATE  pred 
)

Equivalent to AnyOf(begin(iterable), end(iterable), pred).

◆ NoneOf() [1/2]

Bool maxon::NoneOf ( ITERATOR  first,
SENTINEL  sentinel,
PREDICATE  pred 
)

Returns whether the given unary predicate is true none of the elements in a sequence. The predicate function should have a signature equivalent to

Bool func(const ElementType&);

This function is the equivalent to std::none_of.

Parameters
[in]firstStart of sequence.
[in]sentinelSequence delimiter.
[in]predUnary predicate function.
Returns
True if predicate was true none of the elements.

◆ NoneOf() [2/2]

Bool maxon::NoneOf ( const ITERABLE &  iterable,
PREDICATE  pred 
)

Equivalent to NoneOf(begin(iterable), end(iterable), pred).

◆ Equal() [1/4]

Bool maxon::Equal ( ITERATOR1  first1,
SENTINEL1  sentinel1,
ITERATOR2  first2,
SENTINEL2  sentinel2 
)

Returns whether the elements of two sequences are pair-wise equal, i.e. when they have the same length and seq1[i] == se2[i] for all i.

This function is the equivalent to std::equal.

Parameters
[in]first1Start of first sequence.
[in]sentinel1First sequence delimiter.
[in]first2Start of second sequence.
[in]sentinel2Second sequence delimiter.
Returns
True if both sequences are equal.

◆ Equal() [2/4]

Bool maxon::Equal ( const ITERABLE1 &  iterable1,
const ITERABLE2 &  iterable2 
)

Equivalent to Equal(begin(iterable1), end(iterable1), begin(iterable2), end(iterable2)).

◆ Equal() [3/4]

Bool maxon::Equal ( ITERATOR1  first1,
SENTINEL1  sentinel1,
ITERATOR2  first2,
SENTINEL2  sentinel2,
COMPARE  comp 
)

Equivalent to Equal, but uses a custom compare function instead of equality. The compare function should have a signature equivalent to

Bool comp(const ElementType1&, const ElementType2&);
Parameters
[in]first1Start of first sequence.
[in]sentinel1First sequence delimiter.
[in]first2Start of second sequence.
[in]sentinel2Second sequence delimiter.
[in]compBinary compare function.
Returns
True if both sequences are equal.

◆ Equal() [4/4]

Bool maxon::Equal ( const ITERABLE1 &  iterable1,
const ITERABLE2 &  iterable2,
COMPARE  comp 
)

Equivalent to Equal(begin(iterable1), end(iterable1), begin(iterable2), end(iterable2), comp).

◆ Mismatch() [1/4]

auto maxon::Mismatch ( ITERATOR1  first1,
SENTINEL1  sentinel1,
ITERATOR2  first2,
SENTINEL2  sentinel2 
) -> Optional<Pair<ITERATOR1, ITERATOR2>>

Returns whether there's a pair-wise mismatch between elements of two sequences. If no mismatch was found, i.e. both sequences are equal (

See also
Equal), NO_VALUE is returned. If a mismatch was found and both sequences have the same length, a pair of iterators to the mismatching elements is returned. If length(seq1) < length(seq2), a pair (end(seq1), it2) is returned, and vice versa.

This function is the equivalent to std::mismatch.

Parameters
[in]first1Start of first sequence.
[in]sentinel1First sequence delimiter.
[in]first2Start of second sequence.
[in]sentinel2Second sequence delimiter.
Returns
Optional pair of mismatched elements.

◆ Mismatch() [2/4]

auto maxon::Mismatch ( ITERABLE1 &&  iterable1,
ITERABLE2 &&  iterable2 
) -> Optional<Pair<decltype(begin(iterable1)), decltype(begin(iterable2))>>

Equivalent to Mismatch(begin(iterable1), end(iterable1), begin(iterable2), end(iterable2)).

◆ Mismatch() [3/4]

auto maxon::Mismatch ( ITERATOR1  first1,
SENTINEL1  sentinel1,
ITERATOR2  first2,
SENTINEL2  sentinel2,
COMPARE  comp 
) -> Optional<Pair<ITERATOR1, ITERATOR2>>

Equivalent to Mismatch, but uses a custom compare function instead of equality. The compare function should have a signature equivalent to

Bool comp(const ElementType1&, const ElementType2&);
Parameters
[in]first1Start of first sequence.
[in]sentinel1First sequence delimiter.
[in]first2Start of second sequence.
[in]sentinel2Second sequence delimiter.
[in]compBinary compare function.
Returns
Optional pair of mismatched elements.

◆ Mismatch() [4/4]

auto maxon::Mismatch ( ITERABLE1 &&  iterable1,
ITERABLE2 &&  iterable2,
COMPARE  comp 
) -> Optional<Pair<decltype(begin(iterable1)), decltype(begin(iterable2))>>

Equivalent to Mismatch(begin(iterable1), end(iterable1), begin(iterable2), end(iterable2), comp).

◆ Partition() [1/3]

auto maxon::Partition ( ITERATOR  first,
ITERATOR  last,
PREDICATE  pred 
) -> ITERATOR

Reorders elements in sequence [first, last) so that the given unary predicate is true for all elements [first, p) and false for all elements in [p, last), i.e. all elements that match the predicate are placed in front of those that don't. The ordering of the elements is not preserved (

See also
StablePartition). The predicate function should have a signature equivalent to
Bool func(const ElementType&);

This function is the equivalent to std::partition.

Parameters
[in]firstStart of sequence.
[in]lastEnd of sequence.
[in]predUnary predicate function.
Returns
Iterator of partition point p.

◆ Partition() [2/3]

auto maxon::Partition ( ITERATOR  first,
SENTINEL  sentinel,
PREDICATE  pred 
) -> ITERATOR

Equivalent to Partition(first, last, pred). last is determined by incrementing first until it matches the sequence delimiter sentinel.

◆ Partition() [3/3]

auto maxon::Partition ( ITERABLE &&  iterable,
PREDICATE  pred 
) -> decltype(begin(iterable))

Equivalent to Partition(begin(iterable), end(iterable), pred).

◆ IsPartitioned() [1/3]

Bool maxon::IsPartitioned ( ITERATOR  first,
ITERATOR  last,
PREDICATE  pred 
)

Returns whether a sequence is partitioned by the given predicate, i.e. there's a partition point p so that the predicate is true for all [first, p) and false for all [p, last). The predicate function should have a signature equivalent to

Bool func(const ElementType&);

This function is the equivalent to std::is_partitioned.

Parameters
[in]firstStart of sequence.
[in]lastEnd of sequence.
[in]predUnary predicate function.
Returns
True if sequence is partitioned.

◆ IsPartitioned() [2/3]

Bool maxon::IsPartitioned ( ITERATOR  first,
SENTINEL  sentinel,
PREDICATE  pred 
)

Equivalent to IsPartitioned(first, last, pred). last is determined by incrementing first until it matches the sequence delimiter sentinel.

◆ IsPartitioned() [3/3]

Bool maxon::IsPartitioned ( const ITERABLE &  iterable,
PREDICATE  pred 
)

Equivalent to IsPartitioned(begin(iterable), end(iterable), pred).

◆ Reverse() [1/5]

auto maxon::Reverse ( ITERABLE &&  iterable) -> decltype(begin(iterable))

Equivalent to Reverse(begin(iterable), end(iterable)).

◆ LowerBound() [1/6]

auto maxon::LowerBound ( ITERATOR  first,
ITERATOR  last,
const T &  value 
) -> ITERATOR

Returns an iterator to the first element in a sequence that is equal or greater than the given value. If such an element does not exist, the end of the sequence is returned. Binary search is used to locate the element, so the sequence must be ordered. Elements must be comparable with the less-than operator.

This function is the equivalent to std::lower_bound.

Parameters
[in]firstStart of sequence.
[in]lastEnd of sequence.
[in]valueThe bounding value.
Returns
Iterator to position of the lower bound.

◆ LowerBound() [2/6]

auto maxon::LowerBound ( ITERATOR  first,
ITERATOR  last,
const T &  value,
COMPARE  comp 
) -> ITERATOR

Equivalent to LowerBound, but uses the given function to compare elements instead of the less-than operator. The sequence must be ordered by the same function. The compare function should have a signature equivalent to

Bool comp(const ElementType1&, const ElementType2&);
Parameters
[in]firstStart of sequence.
[in]lastEnd of sequence.
[in]valueThe bounding value.
[in]compBinary compare function.
Returns
Iterator to position of the lower bound.

◆ LowerBound() [3/6]

auto maxon::LowerBound ( ITERATOR  first,
SENTINEL  sentinel,
const T &  value 
) -> ITERATOR

Equivalent to LowerBound(first, last, value). last is determined by incrementing first until it matches the sequence delimiter sentinel.

◆ LowerBound() [4/6]

auto maxon::LowerBound ( ITERATOR  first,
SENTINEL  sentinel,
const T &  value,
COMPARE  comp 
) -> ITERATOR

Equivalent to LowerBound(first, last, value, comp). last is determined by incrementing first until it matches the sequence delimiter sentinel.

◆ LowerBound() [5/6]

auto maxon::LowerBound ( ITERABLE &&  iterable,
const T &  value 
) -> decltype(begin(iterable))

Equivalent to LowerBound(begin(iterable), end(iterable), value).

◆ LowerBound() [6/6]

auto maxon::LowerBound ( ITERABLE &&  iterable,
const T &  value,
COMPARE  comp 
) -> decltype(begin(iterable))

Equivalent to LowerBound(begin(iterable), end(iterable), value, comp).

◆ UpperBound() [1/6]

auto maxon::UpperBound ( ITERATOR  first,
ITERATOR  last,
const T &  value 
) -> ITERATOR

Returns an iterator to the first element in a sequence that is greater than the given value. If such an element does not exist, the end of the sequence is returned. Binary search is used to locate the element, so the sequence must be ordered. Elements must be comparable with the less-than operator.

This function is the equivalent to std::upper_bound.

Parameters
[in]firstStart of sequence.
[in]lastEnd of sequence.
[in]valueThe bounding value.
Returns
Iterator to position of the upper bound.

◆ UpperBound() [2/6]

auto maxon::UpperBound ( ITERATOR  first,
ITERATOR  last,
const T &  value,
COMPARE  comp 
) -> ITERATOR

Equivalent to UpperBound, but uses the given function to compare elements instead of the less-than operator. The sequence must be ordered by the same function. The compare function should have a signature equivalent to

Bool comp(const ElementType1&, const ElementType2&);
Parameters
[in]firstStart of sequence.
[in]lastEnd of sequence.
[in]valueThe bounding value.
[in]compBinary compare function.
Returns
Iterator to position of the upper bound.

◆ UpperBound() [3/6]

auto maxon::UpperBound ( ITERATOR  first,
SENTINEL  sentinel,
const T &  value 
) -> ITERATOR

Equivalent to UpperBound(first, last, value). last is determined by incrementing first until it matches the sequence delimiter sentinel.

◆ UpperBound() [4/6]

auto maxon::UpperBound ( ITERATOR  first,
SENTINEL  sentinel,
const T &  value,
COMPARE  comp 
) -> ITERATOR

Equivalent to UpperBound(first, last, value, comp). last is determined by incrementing first until it matches the sequence delimiter sentinel.

◆ UpperBound() [5/6]

auto maxon::UpperBound ( ITERABLE &&  iterable,
const T &  value 
) -> decltype(begin(iterable))

Equivalent to LowerBound(begin(iterable), end(iterable), value).

◆ UpperBound() [6/6]

auto maxon::UpperBound ( ITERABLE &&  iterable,
const T &  value,
COMPARE  comp 
) -> decltype(begin(iterable))

Equivalent to LowerBound(begin(iterable), end(iterable), value, comp).

◆ BinarySearch() [1/6]

auto maxon::BinarySearch ( ITERATOR  first,
ITERATOR  last,
const T &  value 
) -> Optional<ITERATOR>

Returns an iterator to the first element in a sequence that is equal to the given value, or NO_VALUE if no match was found. Binary search is used to locate the element, so the sequence must be ordered. Elements must be comparable with the less-than operator.

Parameters
[in]firstStart of sequence.
[in]lastEnd of sequence.
[in]valueThe bounding value.
Returns
Iterator to position of the found element.

◆ BinarySearch() [2/6]

auto maxon::BinarySearch ( ITERATOR  first,
SENTINEL  sentinel,
const T &  value 
) -> Optional<ITERATOR>

Equivalent to BinarySearch(first, last, value). last is determined by incrementing first until it matches the sequence delimiter sentinel.

◆ BinarySearch() [3/6]

auto maxon::BinarySearch ( ITERATOR  first,
ITERATOR  last,
const T &  value,
COMPARE  comp 
) -> Optional<ITERATOR>

Equivalent to BinarySearch, but uses the given function to compare elements instead of the less-than operator. The sequence must be ordered by the same function. The compare function should have a signature equivalent to

Bool comp(const ElementType1&, const ElementType2&);
Parameters
[in]firstStart of sequence.
[in]lastEnd of sequence.
[in]valueThe bounding value.
[in]compBinary compare function.
Returns
Iterator to position of the upper bound.

◆ BinarySearch() [4/6]

auto maxon::BinarySearch ( ITERATOR  first,
SENTINEL  sentinel,
const T &  value,
COMPARE  comp 
) -> Optional<ITERATOR>

Equivalent to BinarySearch(first, last, value, comp). last is determined by incrementing first until it matches the sequence delimiter sentinel.

◆ BinarySearch() [5/6]

auto maxon::BinarySearch ( ITERABLE &&  iterable,
const T &  value 
) -> decltype(begin(iterable))

Equivalent to BinarySearch(begin(iterable), end(iterable), value).

◆ BinarySearch() [6/6]

auto maxon::BinarySearch ( ITERABLE &&  iterable,
const T &  value,
COMPARE  comp 
) -> decltype(begin(iterable))

Equivalent to BinarySearch(begin(iterable), end(iterable), value, comp).

◆ Rotate() [1/3]

auto maxon::Rotate ( ITERATOR  first,
ITERATOR  last,
ITERATOR  newFirst 
) -> ITERATOR

Rotates elements in sequence [first, last) to the left so that newFirst becomes the new first element.

Example:

CArray<Int> values = { 1, 2, 3, 4, 5, 6 };
auto match = BinarySearch(values, 3);
if (match)
auto it = Rotate(begin(values), end(values), match.GetPosition());
// New order: { 3, 4, 5, 6, 1, 2 }
// it points to position at index 4 (value 1).
maxon::end
MAXON_ATTRIBUTE_FORCE_INLINE auto end(COLLECTION &&c) -> decltype(c.End())
Definition: foreach.h:361
maxon::begin
MAXON_ATTRIBUTE_FORCE_INLINE auto begin(COLLECTION &&c) -> decltype(c.Begin())
Definition: foreach.h:356
maxon::Rotate
auto Rotate(ITERATOR first, ITERATOR last, ITERATOR newFirst) -> ITERATOR
Definition: algorithms.h:1385
maxon::BinarySearch
auto BinarySearch(ITERATOR first, ITERATOR last, const T &value) -> Optional< ITERATOR >
Definition: algorithms.h:1281

This function is the equivalent to std::rotate. Note that the order of the arguments is different here.

Parameters
[in]firstStart of sequence.
[in]lastEnd of sequence.
[in]newFirstIterator to element that should become the new first element.
Returns
Iterator to new position of old first element.

◆ Rotate() [2/3]

auto maxon::Rotate ( ITERABLE &&  iterable,
ITERATOR  newFirst 
) -> ITERATOR

Equivalent to Rotate(begin(iterable), end(iterable), newFirst).

◆ Rotate() [3/3]

auto maxon::Rotate ( ITERATOR  first,
SENTINEL  sentinel,
ITERATOR  newFirst 
) -> ITERATOR

Equivalent to Rotate(first, last, newFirst). last is determined by incrementing first until it matches the sequence delimiter sentinel.

◆ Count() [1/2]

Int maxon::Count ( ITERATOR  first,
SENTINEL  sentinel,
const T &  value 
)

Returns the number of elements in a sequence that are equal to the given value.

This function is the equivalent to std::count.

Parameters
[in]firstStart of sequence.
[in]sentinelSequence delimiter.
[in]valueThe counted value.
Returns
Number of occurrences.

◆ Count() [2/2]

Int maxon::Count ( ITERABLE &&  iterable,
const T &  value 
)

Equivalent to Count(begin(iterable), end(iterable), value).

◆ CountIf() [1/2]

Int maxon::CountIf ( ITERATOR  first,
SENTINEL  sentinel,
PREDICATE  pred 
)

Returns the number of elements in a sequence that are matched by the given predicate. The predicate function should have a signature equivalent to

Bool func(const ElementType&);

This function is the equivalent to std::count_if.

Parameters
[in]firstStart of sequence.
[in]sentinelSequence delimiter.
[in]predUnary predicate.
Returns
Number of occurrences.

◆ CountIf() [2/2]

auto maxon::CountIf ( const ITERABLE &  iterable,
PREDICATE  pred 
) -> Int

Equivalent to CountIf(begin(iterable), end(iterable), pred).

◆ Unique() [1/4]

auto maxon::Unique ( ITERATOR  first,
SENTINEL  sentinel 
) -> ITERATOR

Re-arranges elements in sequence so that consecutive (!) duplicate elements are removed. Relative order of the elements is preserved.

This function is the equivalent to std::unique.

Parameters
[in]firstStart of sequence.
[in]sentinelSequence delimiter.
Returns
End of the re-arranged sequence.

◆ Unique() [2/4]

auto maxon::Unique ( ITERABLE &&  iterable) -> decltype(begin(iterable))

Equivalent to Unique(begin(iterable), end(iterable)).

◆ Unique() [3/4]

auto maxon::Unique ( ITERATOR  first,
SENTINEL  sentinel,
COMPARE  comp 
) -> ITERATOR

Equivalent to Unique, but uses the given function to compare elements instead of the less-than operator. The sequence must be ordered by the same function. The compare function should have a signature equivalent to

Bool comp(const ElementType1&, const ElementType2&);
Parameters
[in]firstStart of sequence.
[in]sentinelSequence delimiter.
[in]compBinary compare function.
Returns
End of the re-arranged sequence.

◆ Unique() [4/4]

auto maxon::Unique ( ITERABLE &&  iterable,
COMPARE  comp 
) -> decltype(begin(iterable))

Equivalent to Unique(begin(iterable), end(iterable), comp).

◆ Remove() [1/2]

auto maxon::Remove ( ITERATOR  first,
SENTINEL  sentinel,
const T &  value 
) -> ITERATOR

Re-arranges elements in a sequence so that elements equal to value are removed. Relative order of the elements is preserved.

This function is the equivalent to std::remove.

Parameters
[in]firstStart of sequence.
[in]sentinelSequence delimiter.
[in]valueThe removed value.
Returns
End of the re-arranged sequence.

◆ Remove() [2/2]

auto maxon::Remove ( ITERABLE &&  iterable,
const T &  value 
) -> decltype(begin(iterable))

Equivalent to Remove(begin(iterable), end(iterable), value).

◆ RemoveIf() [1/2]

auto maxon::RemoveIf ( ITERABLE &&  iterable,
PREDICATE  pred 
) -> decltype(begin(iterable))

Equivalent to RemoveIf(begin(iterable), end(iterable), pred).

◆ Replace() [1/2]

auto maxon::Replace ( ITERATOR  first,
SENTINEL  sentinel,
const T &  oldValue,
const T &  newValue 
) -> ITERATOR

Replaces elements in sequence [first, ...) that are equal to oldValue with copies of newValue.

This function is the equivalent to std::replace.

Parameters
[in]firstStart of sequence.
[in]sentinelSequence delimiter.
[in]oldValueOld value.
[in]newValueNew value.
Returns
End of the modified sequence.

◆ Replace() [2/2]

auto maxon::Replace ( ITERABLE &&  iterable,
const T &  oldValue,
const T &  newValue 
) -> decltype(begin(iterable))

Equivalent to Replace(begin(iterable), end(iterable), oldValue, newValue).

◆ ReplaceIf() [1/2]

auto maxon::ReplaceIf ( ITERATOR  first,
SENTINEL  sentinel,
PREDICATE  pred,
const T &  newValue 
) -> ITERATOR

Replaces elements in sequence [first, ...) that match the given predicate with copies of newValue. The predicate function should have a signature equivalent to

Bool func(const ElementType&);

This function is the equivalent to std::replace.

Parameters
[in]firstStart of sequence.
[in]sentinelSequence delimiter.
[in]predUnary predicate.
[in]newValueNew value.
Returns
End of the modified sequence.

◆ ReplaceIf() [2/2]

auto maxon::ReplaceIf ( ITERABLE &&  iterable,
PREDICATE  pred,
const T &  newValue 
) -> decltype(begin(iterable))

Equivalent to ReplaceIf(begin(iterable), end(iterable), pred, newValue).

◆ Fold() [1/2]

V maxon::Fold ( ITERATOR  first,
SENTINEL  sentinel,
V  initialValue,
BINARYOP  op 
)

Folds elements in the sequence [first, ...) from left to right with a binary function. The folding function should have a signature equivalent to

V func(const V&, const ElementType&);

This function is the equivalent to std::accumulate.

Parameters
[in]firstStart of sequence.
[in]sentinelSequence delimiter.
[in]opFolding function.
Returns
Folded value.

◆ Fold() [2/2]

V maxon::Fold ( const ITERABLE &  iterable,
const V &  intitialValue,
BINARYOP  op 
)

Equivalent to Fold(begin(iterable), end(iterable), initialValue, op).

◆ MinElement() [1/4]

auto maxon::MinElement ( ITERATOR  first,
SENTINEL  sentinel 
) -> Optional<ITERATOR>

Finds the smallest element a sequence, or NO_VALUE if the sequence was empty. Elements must be comparable with the less-than operator.

This function is the equivalent to std::min_element.

Parameters
[in]firstStart of sequence.
[in]sentinelSequence delimiter.
Returns
Iterator to element with minimum value or NO_VALUE.

◆ MinElement() [2/4]

auto maxon::MinElement ( ITERATOR  first,
SENTINEL  sentinel,
COMPARE  comp 
) -> Optional<ITERATOR>

Equivalent to MinElement, but uses the given function to compare elements instead of the less-than operator. The comparison function should have a signature equivalent to

Bool func(const ElementType&, const ElementType&);
Parameters
[in]firstStart of sequence.
[in]sentinelSequence delimiter.
[in]compComparison function.
Returns
Minimum value.

◆ MinElement() [3/4]

auto maxon::MinElement ( ITERABLE &&  iterable) -> Optional<decltype(begin(iterable))>

Equivalent to MinElement(begin(iterable), end(iterable)).

◆ MinElement() [4/4]

auto maxon::MinElement ( ITERABLE &&  iterable,
COMPARE  comp 
) -> Optional<decltype(begin(iterable))>

Equivalent to MinElement(begin(iterable), end(iterable), comp).

◆ MaxElement() [1/4]

auto maxon::MaxElement ( ITERATOR  first,
SENTINEL  sentinel 
) -> Optional<ITERATOR>

Finds the largest element a sequence, or NO_VALUE if the sequence was empty. Elements must be comparable with the less-than operator.

This function is the equivalent to std::max_element.

Parameters
[in]firstStart of sequence.
[in]sentinelSequence delimiter.
Returns
Iterator to element with maximum value or NO_VALUE.

◆ MaxElement() [2/4]

auto maxon::MaxElement ( ITERATOR  first,
SENTINEL  sentinel,
COMPARE  comp 
) -> Optional<ITERATOR>

Equivalent to MaxElement, but uses the given function to compare elements instead of the less-than operator. The comparison function should have a signature equivalent to

Bool func(const ElementType&, const ElementType&);
Parameters
[in]firstStart of sequence.
[in]sentinelSequence delimiter.
[in]compComparison function.
Returns
Maximum value.

◆ MaxElement() [3/4]

auto maxon::MaxElement ( ITERABLE &&  iterable) -> Optional<decltype(begin(iterable))>

Equivalent to MaxElement(begin(iterable), end(iterable)).

◆ MaxElement() [4/4]

auto maxon::MaxElement ( ITERABLE &&  iterable,
COMPARE  comp 
) -> Optional<decltype(begin(iterable))>

Equivalent to MaxElement(begin(iterable), end(iterable), comp).

◆ GetSequenceLength() [1/3]

Int maxon::GetSequenceLength ( ITERATOR  first,
ITERATOR  last 
)

Returns the number of elements in a sequence [first, ... last) as Int(last - first).

◆ GetSequenceLength() [2/3]

Int maxon::GetSequenceLength ( ITERATOR  first,
SENTINEL  sentinel 
)

Equivalent to GetSequenceLength(first, last). last is determined by incrementing first until it matches the sequence delimiter sentinel.

◆ GetSequenceLength() [3/3]

Int maxon::GetSequenceLength ( const ITERABLE &  iterable)

Equivalent to GetSequenceLength(begin(iterable), end(iterable)).

◆ MAXON_ENUM_LIST() [8/95]

enum maxon::NO_MATCH_TYPE maxon::MAXON_ENUM_LIST ( NO_MATCH_TYPE  )

◆ CountIfMatch()

static auto maxon::CountIfMatch ( INDEXABLE &&  indexable,
MATCHER  matcher 
) -> Match<Int>
static

Count the #indexable elements that match the given #matcher.

using MyTup = Tuple<Int, String>;
BaseArray<MyTup> myTups;
// Search for tuple where the first member equals 2 (don't care about the value of second member).
const auto myMatcher = ByValue(2, TupleElementEquals::ByIndex<0>());
const Match<Int> countResult = CountIfMatch(myTups, myMatcher);
if (countResult.GetLength() == 1)
{
DiagnosticOutput("myTup @, first index @", myTups[countResult], countResult.GetPosition());
}
DiagnosticOutput
#define DiagnosticOutput(formatString,...)
Definition: debugdiagnostics.h:176
maxon::ByValue
auto ByValue(const T &value) -> PredicateMatcher< ValuePredicate< T >>
Returns a value matcher for the given value.
Definition: algorithms.h:2579
maxon::CountIfMatch
static auto CountIfMatch(INDEXABLE &&indexable, MATCHER matcher) -> Match< Int >
Definition: algorithms.h:2043
Parameters
[in]indexableIndexable input container.
[in]matcherPattern matcher.
Returns
Match containing index of the first match and total match count.

◆ LinearSearch() [1/2]

auto maxon::LinearSearch ( ITERATOR  first,
SENTINEL  sentinel,
MATCHER  matcher 
) -> Match<ITERATOR>

Searches for the first occurrence of a pattern in a sequence. Different matchers allow to search for specific types of patterns, i.e. single values, sub-sequences, predicates.

Examples:

CArray<Int> values = { 40, 42, 1, 1, 2, 3 };
// Search for value 42
auto match1 = LinearSearch(values.Begin(), values.End(), ByValue(42));
if (match1)
{
auto it = match.GetPosition();
Int length = match.GetLength();
}
// Search for pattern
CArray<Int> pattern = { 1, 2, 3 };
auto match2 = LinearSearch(values, BySequence(pattern));
// Search for a value satisfying a predicate
auto match3 = LinearSearch(values, ByPredicate([] (Int v) { return v < 33; }));
v
PyObject PyObject * v
Definition: abstract.h:297
length
PyWideStringList Py_ssize_t length
Definition: initconfig.h:448
maxon::BySequence
auto BySequence(const SEARCH_SEQ &searchSeq) -> SequenceMatcher< SEARCH_SEQ, maxon::details::EqualityCompare< typename std::iterator_traits< decltype(begin(searchSeq))>::value_type, typename std::iterator_traits< decltype(begin(searchSeq))>::value_type >>
Returns a sequence matcher for the given search sequence.
Definition: algorithms.h:2765
maxon::ByPredicate
auto ByPredicate(const PRED &pred) -> PredicateMatcher< std::reference_wrapper< const PRED >>
Returns a predicate matcher for the given predicate function.
Definition: algorithms.h:2570
maxon::LinearSearch
auto LinearSearch(ITERATOR first, SENTINEL sentinel, MATCHER matcher) -> Match< ITERATOR >
Definition: algorithms.h:2100

This function is the equivalent to std::find, std::search, ...

Parameters
[in]firstStart of sequence.
[in]sentinelSequence delimiter.
[in]matcherPattern matcher.
Returns
Match containing iterator and length to the found subsequence.

◆ LinearSearch() [2/2]

auto maxon::LinearSearch ( ITERABLE &&  iterable,
MATCHER  matcher 
) -> Match<decltype(begin(iterable))>

Equivalent to LinearSearch(begin(iterable), end(iterable), matcher).

◆ Split()

auto maxon::Split ( const ITERABLE &  iterable,
MATCHER  matcher 
) -> Result<BaseArray<ITERABLE>>

Index-based version of LinearSearch. For an index pair (N,M) with N <= M, the input sequence is (indexable[N], indexable[N+1], ... , indexable[M-1]).

Examples:

CArray<Int> values = { 40, 42, 1, 1, 2, 3 };
// Search for value 42
auto match1 = LinearSearchIndex(values.Begin(), values.End(), ByValue(42));
if (match1)
{
Int index = match.GetPosition();
Int length = match.GetLength();
}
@param[in] indexable Indexable container.
@param[in] indexPair Start and end indices of the input sequence.
@param[in] matcher Pattern matcher.
@return Match containing index and length to the found subsequence.
//----------------------------------------------------------------------------------------
template <typename INDEXABLE, typename MATCHER>
inline auto LinearSearchIndex(const INDEXABLE& indexable, IndexPair indexPair, MATCHER matcher) -> Match<Int>
{
return matcher.FindNextIndex(indexable, indexPair);
}
//----------------------------------------------------------------------------------------
Equivalent to LinearSearchIndex(indexable, {0, GetSequenceLength(indexable)}, matcher).
//----------------------------------------------------------------------------------------
template <typename INDEXABLE, typename MATCHER>
inline auto LinearSearchIndex(const INDEXABLE& indexable, MATCHER matcher) -> Match<Int>
{
return matcher.FindNextIndex(indexable, {0, GetSequenceLength(indexable)});
}
//----------------------------------------------------------------------------------------
Splits a sequence into a variable number of parts, whereat the given matcher is used to find separators.
The parts are stored in a BaseArray and of the same type as ITERABLE.
If no separator was found in the sequence, the returned array will be empty.
To create the parts, the ITERABLE type must be constructible with
@code
using IteratorType = decltype(begin(iterable));
ITERABLE(IteratorType pos, Int length);
If
#define If(a0, a1, a2, a3, a4, a5, a6, a7)
Definition: Python-ast.h:514
INDEXABLE
INDEXABLE
The container implements GenericIndexableContainerInterface.
Definition: containerbase.h:10
index
Py_ssize_t * index
Definition: abstract.h:374
indices
Py_ssize_t * indices
Definition: abstract.h:279
pos
void Py_ssize_t * pos
Definition: dictobject.h:50
maxon::GetSequenceLength
Int GetSequenceLength(ITERATOR first, ITERATOR last)
Returns the number of elements in a sequence [first, ... last) as Int(last - first).
Definition: algorithms.h:1872
maxon::IndexPair
Pair< Int, Int > IndexPair
Definition: algorithms.h:33
type
PyObject ** type
Definition: pycore_pyerrors.h:34
iterable
PyObject * iterable
Definition: setobject.h:72
Parameters
[in]iterableInput sequence.
[in]matcherSeparator used to divide the sequence.
Returns
BaseArray containing the parts, or error if allocation failed.

◆ SplitIndex() [1/2]

auto maxon::SplitIndex ( const INDEXABLE &  indexable,
IndexPair  indexPair,
MATCHER  matcher 
) -> Result<BaseArray<Match<Int>>>

Index-based version of Split. For an index pair (N,M) with N <= M, the input sequence is (indexable[N], indexable[N+1], ... , indexable[M-1]). The resulting BaseArray contains Matches, storing the index and length of each split part.

Parameters
[in]indexableIndexable container.
[in]indexPairStart and end indices of the input sequence.
[in]matcherPattern matcher.
Returns
BaseArray containing Matches, or error if allocation failed.

◆ SplitIndex() [2/2]

auto maxon::SplitIndex ( const INDEXABLE &  indexable,
MATCHER  matcher 
) -> Result<void>

Equivalent to SplitIndex(indexable, {0, GetSequenceLength(indexable)}, matcher).

◆ SplitToTuple()

auto maxon::SplitToTuple ( const ITERABLE &  iterable,
MATCHER  matcher 
) -> HomogenousTupleType<COUNT, ITERABLE>

Splits a sequence into COUNT parts, whereat the given matcher is used to find separators. The parts are returned in a Tuple and of the same type as ITERABLE. The split strategy is to fill in the tuple elements from left to right as long as more parts are found. This means if the number of found parts N == COUNT, each element contains exactly one part. If N < COUNT, the last COUNT - N elements are emtpy. If N > COUNT, the last element countains the additional N + COUNT parts (including separators).

To create the parts, the ITERABLE type must be constructible with

using IteratorType = decltype(begin(iterable));
ITERABLE(IteratorType pos, Int length);
Parameters
[in]iterableInput sequence.
[in]matcherSeparator used to divide the sequence.
Returns
Tuple containing split parts.

◆ SplitToTupleIndex() [1/2]

auto maxon::SplitToTupleIndex ( const INDEXABLE &  indexable,
IndexPair  indexPair,
MATCHER  matcher 
) -> HomogenousTupleType<COUNT, Match<Int>>

Index-based version of SplitToTuple. For an index pair (N,M) with N <= M, the input sequence is (indexable[N], indexable[N+1], ... , indexable[M-1]). The resulting Tuple contains Matches, storing the index and length of each split part.

Parameters
[in]indexableIndexable container.
[in]indexPairStart and end indices of the input sequence.
[in]matcherPattern matcher.
Returns
BaseArray containing Matches, or error if allocation failed.

◆ SplitToTupleIndex() [2/2]

auto maxon::SplitToTupleIndex ( const INDEXABLE &  indexable,
MATCHER  matcher 
) -> HomogenousTupleType<COUNT, Match<Int>>

Equivalent to SplitToTupleIndex(indexable, {0, GetSequenceLength(indexable)}, matcher).

◆ SplitIterate()

auto maxon::SplitIterate ( ITERATE_FUNC  iterFunc,
const ITERABLE &  iterable,
MATCHER  matcher 
) -> Result<Bool>

Iteratively splits a sequence into parts, whereat the given matcher is used to find separators. Each successive part is passed as an argument to the iterate function. The iteration terminates when all parts have been processed, or if the iteration returns false or an error. In case of an error, it's passed on as the return value.

To create the parts, the ITERABLE type must be constructible with

using IteratorType = decltype(begin(iterable));
ITERABLE(IteratorType pos, Int length);

The iteration function function should have a signature equivalent to

Bool iterFunc(const ElementType&);
Parameters
[in]iterFuncIteration function.
[in]iterableInput sequence.
[in]matcherSeparator used to divide the sequence.
Returns
True, if no iteration function returned false and at least 1 part was found, false otherwise, or an error.

◆ SplitIterateIndex() [1/2]

auto maxon::SplitIterateIndex ( ITERATE_FUNC  iterFunc,
const INDEXABLE &  indexable,
IndexPair  indexPair,
MATCHER  matcher 
) -> Result<Bool>

Index-based version of SplitIterateIndex. For an index pair (N,M) with N <= M, the input sequence is (indexable[N], indexable[N+1], ... , indexable[M-1]).

The iteration function function should have a signature equivalent to

Bool iterFunc(const ElementType&);
Parameters
[in]iterFuncIteration function.
[in]indexableIndexable container.
[in]indexPairStart and end indices of the input sequence.
[in]matcherPattern matcher.
Returns
True, if no iteration function returned false and at least 1 part was found, false otherwise, or an error.

◆ SplitIterateIndex() [2/2]

auto maxon::SplitIterateIndex ( ITERATE_FUNC  iterFunc,
const INDEXABLE &  indexable,
const MATCHER &  matcher 
) -> Result<Bool>

Equivalent to SplitIterateIndex(iterFunc, indexable, {0, GetSequenceLength(indexable)}, matcher).

◆ ByPredicate()

auto maxon::ByPredicate ( const PRED &  pred) -> PredicateMatcher<std::reference_wrapper<const PRED>>

Returns a predicate matcher for the given predicate function.

◆ ByValue() [1/2]

auto maxon::ByValue ( const T &  value) -> PredicateMatcher<ValuePredicate<T>>

Returns a value matcher for the given value.

◆ ByValue() [2/2]

auto maxon::ByValue ( const T &  value,
const COMPARE &  comp 
) -> PredicateMatcher<ValueComparePredicate<T, COMPARE>>

Returns a value matcher for the given value with a custom comparison function.

◆ ByRepeatingPredicate()

auto maxon::ByRepeatingPredicate ( const PRED &  pred) -> RepeatingPredicateMatcher<PRED>

Returns a repeating predicate matcher for the given predicate function.

◆ ByRepeatingValue() [1/2]

auto maxon::ByRepeatingValue ( const T &  value) -> RepeatingPredicateMatcher<ValuePredicate<T>>

Returns a repeating value matcher for the given value.

◆ ByRepeatingValue() [2/2]

auto maxon::ByRepeatingValue ( const T &  value,
const COMPARE &  comp 
) -> RepeatingPredicateMatcher<ValueComparePredicate<T, COMPARE>>

Returns a repeating value matcher for the given value with a custom comparison function.

◆ BySequence() [1/2]

auto maxon::BySequence ( const SEARCH_SEQ &  searchSeq) -> SequenceMatcher<SEARCH_SEQ, maxon::details::EqualityCompare<typename std::iterator_traits<decltype(begin(searchSeq))>::value_type, typename std::iterator_traits<decltype(begin(searchSeq))>::value_type>>

Returns a sequence matcher for the given search sequence.

◆ BySequence() [2/2]

auto maxon::BySequence ( const SEARCH_SEQ &  searchSeq,
const COMPARE &  comp 
) -> SequenceMatcher<SEARCH_SEQ, COMPARE>

Returns a sequence matcher for the given search sequence with a custom comparison function.

◆ SetDifference() [1/2]

auto maxon::SetDifference ( const ITERABLE1 &  firstSet,
const ITERABLE2 &  secondSet 
) -> Result<ITERABLE1>

Finds the values in the first iterable container that are not contained in the second iterable container and returns them in a container of the same type as the first container. IMPORTANT: The iterators that are retrieved from the input sets needs to iterate of the containers in a sorted order for this algorithm to work.

Parameters
[in]firstSetThe first container.
[in]secondSetThe second container.
Returns
Container of the first container type that contains all the elements of set 1 that are not contained in set 2.

◆ SetDifference() [2/2]

auto maxon::SetDifference ( const ITERABLE1 &  firstSet,
const ITERABLE2 &  secondSet,
APPENDABLE &  outContainer 
) -> Result<void>

Finds the values in the first iterable container that are not contained in the second iterable container and returns them in a container of the same type as the first container. IMPORTANT: The iterators that are retrieved from the input sets needs to iterate of the containers in a sorted order for this algorithm to work.

Parameters
[in]firstSetThe first container.
[in]secondSetThe second container.
[out]outContainerThe container that will contain the elements that are present in the first container but not the second.
Returns
OK if successful.

◆ UnorderedSetDifference() [1/2]

auto maxon::UnorderedSetDifference ( const ITERABLE &  firstSet,
const FINDABLE &  secondSet 
) -> Result<ITERABLE>

Finds the values in the first iterable container that are not contained in the second container and returns them in a container of the same type as the first container.

Parameters
[in]firstSetThe first container.
[in]secondSetThe second container, which must suppor the Contains() function.
Returns
Container of the first container type that contains all the elements of set 1 that are not contained in set 2.

◆ UnorderedSetDifference() [2/2]

auto maxon::UnorderedSetDifference ( const ITERABLE &  firstSet,
const FINDABLE &  secondSet,
APPENDABLE &  outputContainer 
) -> Result<void>

Finds the values in the first iterable container that are not contained in the second container and returns them in a container of the same type as the first container.

Parameters
[in]firstSetThe first container.
[in]secondSetThe second container, which must suppor the Contains() function.
[out]outputContainerContainer of the first container type that contains all the elements of set 1 that are not contained in set 2.
Returns
OK if successful.

◆ ExcludeSetFromSet()

auto maxon::ExcludeSetFromSet ( ERASABLE &  firstSet,
const ITERABLE &  secondSet 
) -> Result<void>

Removes the values in the first iterable container that are contained in the second container and.

Parameters
[in]firstSetThe first container which must support the Erase() member function.
[in]secondSetThe second container.
Returns
Container for the first container type that contains all the elements of set 1 that are not contained in set 2.

◆ Fill() [2/2]

auto maxon::Fill ( ITERATOR  first,
SENTINEL  sentinel,
const T &  value 
) -> ITERATOR

Assigns the given value to all elements in a sequence. The sequence is expected to contain initialized data.

This function is the equivalent to std::fill.

Parameters
[in]firstStart of sequence.
[in]sentinelSequence delimiter.
[in]valueThe assigned value.
Returns
End of filled sequence.

◆ Reverse() [2/5]

auto maxon::Reverse ( ITERATOR  first,
ITERATOR  last 
) -> ITERATOR

Reverses the order of the elements in a sequence.

This function is the equivalent to std::reverse.

Parameters
[in]firstStart of sequence.
[in]lastEnd of sequence.
Returns
End of the reversed sequence.

◆ Reverse() [3/5]

auto maxon::Reverse ( ITERATOR  first,
SENTINEL  sentinel 
) -> ITERATOR

Equivalent to Reverse(first, last). last is determined by incrementing first until it matches the sequence delimiter sentinel.

◆ RemoveIf() [2/2]

auto maxon::RemoveIf ( ITERATOR  first,
SENTINEL  sentinel,
PREDICATE  pred 
) -> ITERATOR

Re-arranges elements in a sequence so that elements matching the given predicate are removed. Relative order of the elements is preserved. The predicate function should have a signature equivalent to

Bool func(const ElementType&);

This function is the equivalent to std::remove_if.

Parameters
[in]firstStart of sequence.
[in]sentinelSequence delimiter.
[in]predUnary predicate.
Returns
End of the re-arranged sequence.

◆ ConvertLocalDateTimeToTM()

MAXON_ATTRIBUTE_FORCE_INLINE tm maxon::ConvertLocalDateTimeToTM ( const LocalDateTime &  dateTime)

◆ ConvertTMToLocalDateTime()

MAXON_ATTRIBUTE_FORCE_INLINE LocalDateTime maxon::ConvertTMToLocalDateTime ( const tm &  st)

◆ mktime_r()

MAXON_ATTRIBUTE_FORCE_INLINE time_t maxon::mktime_r ( struct tm *  tm)

◆ timegm_r()

MAXON_ATTRIBUTE_FORCE_INLINE time_t maxon::timegm_r ( struct tm *  tm)

◆ MAXON_ENUM_ORDERED_FLAGS() [1/2]

enum maxon::VALUEKIND UInt64 maxon::MAXON_ENUM_ORDERED_FLAGS ( VALUEKIND  ,
"net.maxon.datatype.enum.valuekind"  ,
EARLY   
)

◆ MAXON_ENUM_LIST() [9/95]

enum maxon::COLLECTION_KIND maxon::MAXON_ENUM_LIST ( COLLECTION_KIND  )

◆ __attribute__()

maxon::__attribute__ ( (always_inline)  ) &&

◆ PrivateGetDataType() [1/17]

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

◆ MAXON_IMPLEMENTATION_SIMPLE_REGISTER() [1/5]

maxon::MAXON_IMPLEMENTATION_SIMPLE_REGISTER ( ArrayImpl< ARRAY >  )

◆ ToArrayPtr()

const ArrayInterface<T>* maxon::ToArrayPtr ( const ArrayInterface< T > &  array)

Returns a pointer to the array reference argument. This function is useful if you have to convert some array to a pointer to an ArrayInterface:

void Func(const ArrayInterface<const Char>* array);
BlockArray<Char> myArray;
Func(ToArrayPtr(myArray));
maxon::ToArrayPtr
const ArrayInterface< T > * ToArrayPtr(const ArrayInterface< T > &array)
Definition: array.h:2076

For WritableArrayInterface parameters, use ToWritableArrayPtr instead.

See also
ArrayInterface.
Template Parameters
TType of elements of the array, this is deduced by the compiler.
Note
If the argument is a temporary (which usually is the case), the result will be a pointer to a temporary. Make sure that the pointer is used only within the lifetime of the temporary. For the above example, it suffices that Func uses the array only during its execution.

◆ ToWritableArrayPtr()

WritableArrayInterface<T>* maxon::ToWritableArrayPtr ( WritableArrayInterface< T > &  array)

Returns a pointer to the array reference argument. This function is useful if you have to convert some array to a pointer to an ArrayInterface:

void Func(WritableArrayInterface<const Char>* array);
BlockArray<Char> myArray;
Func(ToWritableArrayPtr(myArray));
maxon::ToWritableArrayPtr
WritableArrayInterface< T > * ToWritableArrayPtr(WritableArrayInterface< T > &array)
Definition: array.h:2101

For non-modifiable array parameters, use ToArrayPtr instead.

See also
ArrayInterface.
Template Parameters
TType of elements of the array, this is deduced by the compiler.
Note
If the argument is a temporary (which usually is the case), the result will be a pointer to a temporary. Make sure that the pointer is used only within the lifetime of the temporary. For the above example, it suffices that Func uses the array only during its execution.

◆ MAXON_DATATYPE() [13/66]

maxon::MAXON_DATATYPE ( BackgroundEntryTuple  ,
"net.maxon.datatyoe.backgroundentrytuple"   
)

◆ MAXON_DATATYPE() [14/66]

maxon::MAXON_DATATYPE ( BitSet  ,
"net.maxon.datatype.bitset"   
)

◆ ConstExprStringsAreEqual()

constexpr Bool maxon::ConstExprStringsAreEqual ( const Char *  str1,
const Char *  str2 
)
constexpr

◆ MAXON_ENUM_LIST() [10/95]

enum maxon::BYTEORDER maxon::MAXON_ENUM_LIST ( BYTEORDER  )

◆ SwapByteOrder() [1/6]

MAXON_ATTRIBUTE_FORCE_INLINE UInt16 maxon::SwapByteOrder ( UInt16  data)

Swaps the memory layout of a value from big to little endian or vice versa.

Parameters
[in]dataValue that will be swapped.
Returns
Swapped value.

◆ SwapByteOrder() [2/6]

MAXON_ATTRIBUTE_FORCE_INLINE Int16 maxon::SwapByteOrder ( Int16  data)

Swaps the memory layout of a value from big to little endian or vice versa.

Parameters
[in]dataValue that will be swapped.
Returns
Swapped value.

◆ SwapByteOrder() [3/6]

MAXON_ATTRIBUTE_FORCE_INLINE UInt32 maxon::SwapByteOrder ( UInt32  data)

Swaps the memory layout of a value from big to little endian and vice versa.

Parameters
[in]dataValue that will be swapped.
Returns
Swapped value.

◆ SwapByteOrder() [4/6]

MAXON_ATTRIBUTE_FORCE_INLINE Int32 maxon::SwapByteOrder ( Int32  data)

Swaps the memory layout of a value from big to little endian or vice versa.

Parameters
[in]dataValue that will be swapped.
Returns
Swapped value.

◆ SwapByteOrder() [5/6]

MAXON_ATTRIBUTE_FORCE_INLINE UInt64 maxon::SwapByteOrder ( UInt64  data)

Swaps the memory layout of a value from big to little endian and vice versa.

Parameters
[in]dataValue that will be swapped.
Returns
Swapped value.

◆ SwapByteOrder() [6/6]

MAXON_ATTRIBUTE_FORCE_INLINE Int64 maxon::SwapByteOrder ( Int64  data)

Swaps the memory layout of a value from big to little endian or vice versa.

Parameters
[in]dataValue that will be swapped.
Returns
Swapped value.

◆ SwapUInt16() [1/2]

MAXON_ATTRIBUTE_FORCE_INLINE UInt16 maxon::SwapUInt16 ( UInt16  data)

Swaps the memory layout of a value from big to little endian or vice versa.

Parameters
[in]dataValue that will be swapped.
Returns
Swapped value.

◆ SwapInt16() [1/2]

MAXON_ATTRIBUTE_FORCE_INLINE Int16 maxon::SwapInt16 ( Int16  data)

Swaps the memory layout of a value from big to little endian or vice versa.

Parameters
[in]dataValue that will be swapped.
Returns
Swapped value.

◆ SwapUInt32() [1/2]

MAXON_ATTRIBUTE_FORCE_INLINE UInt32 maxon::SwapUInt32 ( UInt32  data)

Swaps the memory layout of a value from big to little endian or vice versa.

Parameters
[in]dataValue that will be swapped.
Returns
Swapped value.

◆ SwapInt32() [1/2]

MAXON_ATTRIBUTE_FORCE_INLINE Int32 maxon::SwapInt32 ( Int32  data)

Swaps the memory layout of a value from big to little endian or vice versa.

Parameters
[in]dataValue that will be swapped.
Returns
Swapped value.

◆ SwapUInt64() [1/2]

MAXON_ATTRIBUTE_FORCE_INLINE UInt64 maxon::SwapUInt64 ( UInt64  data)

Swaps the memory layout of a value from big to little endian or vice versa.

Parameters
[in]dataValue that will be swapped.
Returns
Swapped value.

◆ SwapInt64() [1/2]

MAXON_ATTRIBUTE_FORCE_INLINE Int64 maxon::SwapInt64 ( Int64  data)

Swaps the memory layout of a value from big to little endian or vice versa.

Parameters
[in]dataValue that will be swapped.
Returns
Swapped value.

◆ SwapUInt16() [2/2]

MAXON_ATTRIBUTE_FORCE_INLINE void maxon::SwapUInt16 ( UInt16 *  addr,
Int  count = 1 
)

Swaps the memory layout of multiple values from big to little endian and vice versa.

Parameters
[in]addrPointer to elements that will be swapped.
[in]countNumber of elements that will be swapped.

◆ SwapInt16() [2/2]

MAXON_ATTRIBUTE_FORCE_INLINE void maxon::SwapInt16 ( Int16 *  addr,
Int  count = 1 
)

Swaps the memory layout of multiple values from big to little endian and vice versa.

Parameters
[in]addrPointer to elements that will be swapped.
[in]countNumber of elements that will be swapped.

◆ SwapUInt32() [2/2]

MAXON_ATTRIBUTE_FORCE_INLINE void maxon::SwapUInt32 ( UInt32 *  addr,
Int  count = 1 
)

Swaps the memory layout of multiple values from big to little endian and vice versa.

Parameters
[in]addrPointer to elements that will be swapped.
[in]countNumber of elements that will be swapped.

◆ SwapInt32() [2/2]

MAXON_ATTRIBUTE_FORCE_INLINE void maxon::SwapInt32 ( Int32 *  addr,
Int  count = 1 
)

Swaps the memory layout of multiple values from big to little endian and vice versa.

Parameters
[in]addrPointer to elements that will be swapped.
[in]countNumber of elements that will be swapped.

◆ SwapUInt64() [2/2]

MAXON_ATTRIBUTE_FORCE_INLINE void maxon::SwapUInt64 ( UInt64 *  addr,
Int  count = 1 
)

Swaps the memory layout of multiple values from big to little endian and vice versa.

Parameters
[in]addrPointer to elements that will be swapped.
[in]countNumber of elements that will be swapped.

◆ SwapInt64() [2/2]

MAXON_ATTRIBUTE_FORCE_INLINE void maxon::SwapInt64 ( Int64 *  addr,
Int  count = 1 
)

Swaps the memory layout of multiple values from big to little endian and vice versa.

Parameters
[in]addrPointer to elements that will be swapped.
[in]countNumber of elements that will be swapped.

◆ ByteOrder_UInt16()

MAXON_ATTRIBUTE_FORCE_INLINE void maxon::ByteOrder_UInt16 ( UInt16 *  addr,
Int  count = 1 
)

Converts from a given byte order to the current system's byte order and vice versa. If the byte order matches the system's byte order nothing will be done.

Template Parameters
orderByte order of the data.
Parameters
[in]addrPointer to the data.
[in]countNumber of elements.

◆ ByteOrder_Int16()

MAXON_ATTRIBUTE_FORCE_INLINE void maxon::ByteOrder_Int16 ( Int16 *  addr,
Int  count = 1 
)

Converts from a given byte order to the current system's byte order and vice versa. If the byte order matches the system's byte order nothing will be done.

Template Parameters
orderByte order of the data.
Parameters
[in]addrPointer to the data.
[in]countNumber of elements.

◆ ByteOrder_UInt32()

MAXON_ATTRIBUTE_FORCE_INLINE void maxon::ByteOrder_UInt32 ( UInt32 *  addr,
Int  count = 1 
)

Converts from a given byte order to the current system's byte order and vice versa. If the byte order matches the system's byte order nothing will be done.

Template Parameters
orderByte order of the data.
Parameters
[in]addrPointer to the data.
[in]countNumber of elements.

◆ ByteOrder_Int32()

MAXON_ATTRIBUTE_FORCE_INLINE void maxon::ByteOrder_Int32 ( Int32 *  addr,
Int  count = 1 
)

Converts from a given byte order to the current system's byte order and vice versa. If the byte order matches the system's byte order nothing will be done.

Template Parameters
orderByte order of the data.
Parameters
[in]addrPointer to the data.
[in]countNumber of elements.

◆ ByteOrder_UInt64()

MAXON_ATTRIBUTE_FORCE_INLINE void maxon::ByteOrder_UInt64 ( UInt64 *  addr,
Int  count = 1 
)

Converts from a given byte order to the current system's byte order and vice versa. If the byte order matches the system's byte order nothing will be done.

Template Parameters
orderByte order of the data.
Parameters
[in]addrPointer to the data.
[in]countNumber of elements.

◆ ByteOrder_Int64()

MAXON_ATTRIBUTE_FORCE_INLINE void maxon::ByteOrder_Int64 ( Int64 *  addr,
Int  count = 1 
)

Converts from a given byte order to the current system's byte order and vice versa. If the byte order matches the system's byte order nothing will be done.

Template Parameters
orderByte order of the data.
Parameters
[in]addrPointer to the data.
[in]countNumber of elements.

◆ MAXON_DATATYPE() [15/66]

maxon::MAXON_DATATYPE ( BytesValue  ,
"net.maxon.datatype.bytesvalue"   
)

◆ ScanParameter() [1/2]

void maxon::ScanParameter ( BytesValue &  res,
const Block< const Utf32Char > &  str,
Int &  processed,
const String &  formatStatement,
Bool &  error 
)

Helper function to use ScanString ScanParameter description. Do not call on your own! Usage:

BytesValue bytes;
String valueStr = "20MB"_s;
Bool res = ScanString(valueStr, "@", bytes);
String
Definition: c4d_string.h:39
bytes
void const void * bytes
Definition: bytesobject.h:117
res
Py_UCS4 * res
Definition: unicodeobject.h:1113
maxon::ScanString
Bool ScanString(STR inputStr, STR2 formatStr, ARGS &... args)
Definition: string.h:2146

◆ MAXON_ENUM_LIST() [11/95]

enum maxon::CONFIGURATION_CATEGORY maxon::MAXON_ENUM_LIST ( CONFIGURATION_CATEGORY  )

◆ MAXON_ENUM_LIST() [12/95]

enum maxon::CONFIGURATIONENTRY_ORIGIN maxon::MAXON_ENUM_LIST ( CONFIGURATIONENTRY_ORIGIN  )

◆ MAXON_ENUM_LIST() [13/95]

enum maxon::CONFIGURATIONENTRY_STATE maxon::MAXON_ENUM_LIST ( CONFIGURATIONENTRY_STATE  )

◆ MAXON_DATATYPE() [16/66]

maxon::MAXON_DATATYPE ( ConfigInit  ,
"net.maxon.datatype.configinit"   
)

◆ MAXON_DEPENDENCY() [1/2]

maxon::MAXON_DEPENDENCY ( configuration  )

◆ QueryConfigBool()

Bool maxon::QueryConfigBool ( const String &  symbol)

◆ PrivateGetDataType() [2/17]

ResultOk<const ContainerDataType<T...>&> maxon::PrivateGetDataType ( ContainerInterface< T... > **  ,
OverloadRank1   
)

◆ PrivateGetDataType() [3/17]

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

◆ MAXON_DEPENDENCY() [2/2]

maxon::MAXON_DEPENDENCY ( cpuidinit  )

◆ operator==() [1/8]

MAXON_ATTRIBUTE_FORCE_INLINE bool maxon::operator== ( const CustomSTLAllocator< T1 > &  ,
const CustomSTLAllocator< T2 > &   
)
noexcept

◆ operator!=() [1/7]

MAXON_ATTRIBUTE_FORCE_INLINE bool maxon::operator!= ( const CustomSTLAllocator< T1 > &  ,
const CustomSTLAllocator< T2 > &   
)
noexcept

◆ MAXON_REGISTRY() [19/60]

maxon::MAXON_REGISTRY ( DataType  ,
LegacyDataTypeIdentifiers  ,
"net.maxon.registry.datatype.legacyidentifiers"   
)

This extension point allows to declare new DataType to be used with deprecated identifiers. Register any deprecated type that needs to be converted with this line: MAXON_DECLARATION_REGISTER(maxon::LegacyDataTypeIdentifiers, "net.maxon.mograph.legacyshadingdata") { return GetDataType<NewShadingData>(); }

◆ MAXON_DATATYPE() [17/66]

maxon::MAXON_DATATYPE ( LanguageStringDataDescription  ,
"net.maxon.datatype.languagestringdatadescription"   
)

◆ MAXON_DATATYPE() [18/66]

maxon::MAXON_DATATYPE ( VariadicIdsElement  ,
"net.maxon.datatype.variadicidselement"   
)

◆ AddResourceDefault() [1/2]

Result<void> maxon::AddResourceDefault ( DataDictionary &  props,
const T &  t,
OverloadRank0   
)

◆ AddResourceDefault() [2/2]

SFINAEHelper<Result<void>, typename T::HasDefault>::type maxon::AddResourceDefault ( DataDictionary &  props,
const T &  t,
OverloadRank1   
)

◆ BlockToEnumArray()

Result<BaseArray<Tuple<Id, Data> > > maxon::BlockToEnumArray ( const Block< TYPE > &  enumBlock)

Converts a given Block<TYPE> to a enum list array to use with DESCRIPTION::DATA::BASE::ENUM.

Parameters
[in]enumBlockBlock to convert into a array.
Returns
BaseArray on success.

◆ AddResourceProperty()

Result<void> maxon::AddResourceProperty ( DataDescription &  description,
const T &  t,
const Delegate< Result< void >(DataDictionary &props)> &  addProps = nullptr 
)

◆ EraseResourceProperty()

Result<void> maxon::EraseResourceProperty ( DataDescription &  description,
const T &  t 
)

◆ MAXON_ENUM_LIST() [14/95]

enum maxon::CONDITIONTOKENTYPE maxon::MAXON_ENUM_LIST ( CONDITIONTOKENTYPE  )

◆ MAXON_DATATYPE() [19/66]

maxon::MAXON_DATATYPE ( ProcessEnumListDelegate  ,
"net.maxon.datatype.processenumlistdelegate"   
)

◆ MAXON_REGISTRY() [20/60]

maxon::MAXON_REGISTRY ( ProcessEnumListDelegate  ,
ProcessEnumListDelegates  ,
"net.maxon.datadescription.registry.processenumlist"   
)

GetEffectiveEnumList will utilize this registry to replace extension points.

◆ MAXON_DATATYPE() [20/66]

maxon::MAXON_DATATYPE ( EnumVariableResolveDelegate  ,
"net.maxon.datatype.delegate.enumvariableresolve"   
)

◆ MAXON_REGISTRY() [21/60]

maxon::MAXON_REGISTRY ( EnumVariableResolveDelegate  ,
EnumVariableResolveDelegates  ,
"net.maxon.datadescription.registry.enumvariableresolve"   
)

GetEffectiveEnumList will utilize this registry to resolve enums and presets which need their identifier to be resolved before use. For instance, "net.maxon.description.base.preset.{re_selectedtype}" must be resolved to something like "net.maxon.description.base.preset.float" to fetch the correct preset database.

See also
VARIABLEID_PREFIX.

◆ UseFilterData()

Bool maxon::UseFilterData ( const Data *  filterData,
const Data &  compare 
)

Helper function to use with ProcessEnumListDelegate to verify if a type needs to be added to the output array.

Parameters
[in]filterDataForward filterData from delegate.
[in]compareData that would be added. check before doing more complex operations.
Returns
True to process the data, false to ignore this entry.

◆ MAXON_ENUM_FLAGS() [8/33]

enum maxon::GETDATAFLAGS maxon::MAXON_ENUM_FLAGS ( GETDATAFLAGS  )

◆ MAXON_DECLARATION() [18/84]

maxon::MAXON_DECLARATION ( Class< DataDescriptionDefinition >  ,
DataDescriptionDefinitionClass  ,
"net.maxon.class.datadescriptiondefinition"   
)

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_DATATYPE() [21/66]

maxon::MAXON_DATATYPE ( LanguageStringDataDescriptionDefinition  ,
"net.maxon.datatype.languagestringdatadescriptiondefinition"   
)

◆ MAXON_ENUM_ORDERED_LIST() [1/2]

enum maxon::DBVERSION maxon::MAXON_ENUM_ORDERED_LIST ( DBVERSION  )

◆ MAXON_ENUM_FLAGS() [9/33]

enum maxon::DESCRIPTIONMESSAGECHECKFLAGS maxon::MAXON_ENUM_FLAGS ( DESCRIPTIONMESSAGECHECKFLAGS  )

◆ MAXON_DATATYPE() [22/66]

maxon::MAXON_DATATYPE ( DescriptionMessageCall  ,
"net.maxon.datatype.descriptionmessagecall"   
)

◆ MAXON_ENUM_LIST() [15/95]

enum maxon::LOADDESCRIPTIONMODE maxon::MAXON_ENUM_LIST ( LOADDESCRIPTIONMODE  )

◆ MAXON_DECLARATION() [19/84]

maxon::MAXON_DECLARATION ( Class< DataDescriptionObjectRef >  ,
DataDescriptionObjectClass  ,
"net.maxon.class.datadescriptionobject"   
)

◆ MAXON_REGISTRY() [22/60]

maxon::MAXON_REGISTRY ( DataFormatReaderFactory  ,
DataFormatReaderFactories  ,
"net.maxon.registry.dataformatreaderfactories"   
)

Registry to register/iterate all available DataSerialize Reader implementations.

◆ MAXON_REGISTRY() [23/60]

maxon::MAXON_REGISTRY ( DataFormatWriterFactory  ,
DataFormatWriterFactories  ,
"net.maxon.registry.dataformatwriterfactories"   
)

Registry to register/iterate all available DataSerialize Writer implementations.

◆ MAXON_DECLARATION() [20/84]

maxon::MAXON_DECLARATION ( Class< DataFormatWriterRef >  ,
DataFormatWriterBinaryClass  ,
"net.maxon.class.dataformatwriterbinary"   
)

◆ MAXON_DECLARATION() [21/84]

maxon::MAXON_DECLARATION ( Class< DataFormatWriterRef >  ,
DataFormatWriterJsonClass  ,
"net.maxon.class.dataformatwriterjson"   
)

◆ MAXON_DECLARATION() [22/84]

maxon::MAXON_DECLARATION ( Class< DataFormatWriterRef >  ,
DataFormatWriterXmlClass  ,
"net.maxon.class.dataformatwriterxml"   
)

◆ MAXON_DECLARATION() [23/84]

maxon::MAXON_DECLARATION ( Class< DataFormatReaderRef >  ,
DataFormatReaderBinaryClass  ,
"net.maxon.class.dataformatreaderbinary"   
)

◆ MAXON_DECLARATION() [24/84]

maxon::MAXON_DECLARATION ( Class< DataFormatReaderRef >  ,
DataFormatReaderJsonClass  ,
"net.maxon.class.dataformatreaderjson"   
)

◆ MAXON_DECLARATION() [25/84]

maxon::MAXON_DECLARATION ( Class< DataFormatReaderRef >  ,
DataFormatReaderXmlClass  ,
"net.maxon.class.dataformatreaderxml"   
)

◆ MAXON_DATATYPE() [23/66]

maxon::MAXON_DATATYPE ( IDENT_VOID  ,
"net.maxon.ident_void"   
)

◆ CreateHelper()

ResultPtr<void> maxon::CreateHelper ( )

◆ DeleteHelper()

void maxon::DeleteHelper ( void *  helper)

◆ ReadHelper()

Result<void> maxon::ReadHelper ( DataSerializeInterface *  ds,
void *  classPtr,
void *  helperPtr,
UInt  elementHash 
)

◆ WriteHelper()

Result<void> maxon::WriteHelper ( DataSerializeInterface *  ds,
void *  classPtr,
void *  helperPtr,
UInt  elementHash 
)

◆ ArrayConversionHelper()

void maxon::ArrayConversionHelper ( void *  arrayPtr,
Char *  memBuffer 
)

◆ SetConversionHelper()

void maxon::SetConversionHelper ( void *  mapPtr,
Char *  memBuffer 
)

◆ MapConversionHelper()

void maxon::MapConversionHelper ( void *  mapPtr,
Char *  memBuffer 
)

◆ operator|()

DESCRIBEFLAGS maxon::operator| ( DESCRIBEFLAGS  a,
DESCRIBEFLAGS  b 
)

◆ operator&()

DESCRIBEFLAGS maxon::operator& ( DESCRIBEFLAGS  a,
DESCRIBEFLAGS  b 
)

◆ operator~()

DESCRIBEFLAGS maxon::operator~ ( DESCRIBEFLAGS  a)

◆ operator&=()

DESCRIBEFLAGS& maxon::operator&= ( DESCRIBEFLAGS &  a,
DESCRIBEFLAGS  b 
)

◆ MAXON_ENUM_FLAGS() [10/33]

enum maxon::PREPAREHELPERFLAGS maxon::MAXON_ENUM_FLAGS ( PREPAREHELPERFLAGS  )

◆ MAXON_DECLARATION() [26/84]

maxon::MAXON_DECLARATION ( Class< DataSerializeRef >  ,
DataSerializeBaseClass  ,
"net.maxon.class.dataserializebase"   
)

Default implementation of DataSerializeInterface.

◆ MAXON_DECLARATION() [27/84]

maxon::MAXON_DECLARATION ( Class< DataSerializeReaderRef >  ,
DataSerializeReaderClass  ,
"net.maxon.class.dataserializereader"   
)

Default implementation of DataSerializeReaderInterface.

◆ MAXON_DECLARATION() [28/84]

maxon::MAXON_DECLARATION ( Class< DataSerializeWriterRef >  ,
DataSerializeWriterClass  ,
"net.maxon.class.dataserializewriter"   
)

Default implementation of DataSerializeWriterInterface.

◆ PrivateGetDataType() [4/17]

std::enable_if<STD_IS_REPLACEMENT(enum, T), ResultOk<const DataType&> >::type maxon::PrivateGetDataType ( T **  ,
OverloadRank0   
)

◆ PrivateGetDataType() [5/17]

std::enable_if<GetDirectlyReferencedType<T>::value, Result<DataType> >::type maxon::PrivateGetDataType ( T **  ,
OverloadRank0   
)

◆ PrivateGetDataType() [6/17]

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

◆ MAXON_DATATYPE_EARLY_ENUM() [1/7]

maxon::MAXON_DATATYPE_EARLY_ENUM ( WRITEMETA  ,
"net.maxon.datatype.enum.writemeta"   
)

◆ MAXON_DATATYPE_EARLY_ENUM() [2/7]

maxon::MAXON_DATATYPE_EARLY_ENUM ( TARGETAUDIENCE  ,
"net.maxon.datatype.enum.targetaudience"   
)

◆ MAXON_DATATYPE_EARLY_ENUM() [3/7]

maxon::MAXON_DATATYPE_EARLY_ENUM ( OUTPUT  ,
"net.maxon.datatype.enum.output"   
)

◆ MAXON_DATATYPE_EARLY_ENUM() [4/7]

maxon::MAXON_DATATYPE_EARLY_ENUM ( VALUEKIND  ,
"net.maxon.datatype.enum.valuekind"   
)

◆ MAXON_DATATYPE_EARLY_ENUM() [5/7]

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

◆ MAXON_DATATYPE_EARLY_ENUM() [6/7]

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

◆ MAXON_DATATYPE_EARLY_ENUM() [7/7]

maxon::MAXON_DATATYPE_EARLY_ENUM ( COLLECTION_RESIZE_FLAGS  ,
"net.maxon.datatype.enum.collection_resize_flags"   
)

◆ MAXON_ENUM_LIST() [16/95]

enum maxon::DATATYPEBUILDERNAME maxon::MAXON_ENUM_LIST ( DATATYPEBUILDERNAME  )

◆ MAXON_DATATYPE() [24/66]

maxon::MAXON_DATATYPE ( DataTypeBuilderEntry  ,
"net.maxon.datatype.datatypebuilderentry"   
)

◆ MAXON_REGISTRY() [24/60]

maxon::MAXON_REGISTRY ( DataTypeBuilderEntry  ,
DataTypeBuilderRegistry  ,
"net.maxon.registry.datatypebuilderregistry"   
)

◆ MAXON_ENUM_LIST() [17/95]

enum maxon::DAYOFWEEK maxon::MAXON_ENUM_LIST ( DAYOFWEEK  )

◆ MAXON_ENUM_LIST() [18/95]

enum maxon::DST Int16 maxon::MAXON_ENUM_LIST ( DST  )

◆ MAXON_ENUM_LIST() [19/95]

enum maxon::JULIANDATE maxon::MAXON_ENUM_LIST ( JULIANDATE  )

◆ MAXON_DATATYPE() [25/66]

maxon::MAXON_DATATYPE ( UniversalDateTime  ,
"net.maxon.datatype.universaldatetime"   
)

◆ MAXON_DATATYPE() [26/66]

maxon::MAXON_DATATYPE ( LocalDateTime  ,
"net.maxon.datatype.localdatetime"   
)

◆ ScanParameter() [2/2]

void maxon::ScanParameter ( UniversalDateTime &  res,
const Block< const Utf32Char > &  str,
Int &  processed,
const String &  formatStatement,
Bool &  error 
)

Helper function to use ScanString ScanParameter description. Do not call on your own! Usage:

UniversalDateTime date;
String valueStr = "2020-10-23"_s;
Bool res = ScanString(valueStr, "@", date);

◆ MAXON_ENUM_LIST() [20/95]

enum maxon::HARDWAREBREAKPOINTTYPE maxon::MAXON_ENUM_LIST ( HARDWAREBREAKPOINTTYPE  )

◆ MAXON_ENUM_LIST() [21/95]

enum maxon::HARDWAREBREAKPOINTSIZE maxon::MAXON_ENUM_LIST ( HARDWAREBREAKPOINTSIZE  )

◆ sprintf_safe()

Int maxon::sprintf_safe ( Char *  _DstBuf,
Int  _MaxCount,
const Char *  _Format,
  ... 
)

◆ MAXON_DECLARATION() [29/84]

maxon::MAXON_DECLARATION ( ComponentDescriptor  ,
EagerDecoratorComponent  ,
"net.maxon.component.eagerdecorator"   
)

◆ MAXON_DECLARATION() [30/84]

maxon::MAXON_DECLARATION ( ComponentDescriptor  ,
WeakDecoratorComponent  ,
"net.maxon.component.weakdecorator"   
)

◆ _ReallocMem()

MAXON_ATTRIBUTE_FORCE_INLINE ResultPtr<T> maxon::_ReallocMem ( T *  p,
Int  cnt,
MAXON_SOURCE_LOCATION_DECLARATION   
)

Resizes a raw memory block : no constructors are called! The content of the memory block is preserved up to the lesser of the new and old sizes, even if the block is moved to a new location. The additional memory is not cleared, it may contain a certain byte pattern in debug mode. In case that p is a nullptr the function behaves like NewMem. If the function fails to allocate the requested block of memory a nullptr is returned and the memory block pointed to by argument p is not deallocated (it is still valid with its contents unchanged). THREADSAFE.

Parameters
[in]pCurrent memory block (can be nullptr)
[in]cntNew number of items (size of the memory block is n * sizeof(T))
[in]allocLocationPass MAXON_SOURCE_LOCATION(_NAME) to add the current source line and file.
Returns
Memory block address or nullptr if resize is not possible (p is still valid in this case)

◆ DeleteMem()

void maxon::DeleteMem ( T *&  p)

Frees a raw memory block: no destructors are called! THREADSAFE.

Parameters
[in]pMemory block (can be nullptr, will be nullptr after return)

◆ DeleteConstPtrMem()

void maxon::DeleteConstPtrMem ( const void *  p)

Frees a raw memory block: no destructors are called! Normally you should use DeleteMemj(). This variant should be used only in the rare case when the object pointer is a constant so that it can't be set to nullptr. THREADSAFE.

Parameters
[in]pMemory block (can be nullptr).

◆ MemCopy()

MAXON_ATTRIBUTE_FORCE_INLINE void maxon::MemCopy ( void *  dst,
const void *  src,
Int  size 
)

Copies raw memory if size >0; source and destination pointers are tested against nullptr source and destination memory must not overlap THREADSAFE.

Parameters
[out]dstMemory destination.
[in]srcMemory source.
[in]sizeNumber of bytes to be copied.

◆ MemMove()

MAXON_ATTRIBUTE_FORCE_INLINE void maxon::MemMove ( void *  dst,
const void *  src,
Int  size 
)

Moves raw memory if size >0; source and destination pointers are tested against nullptr source and destination memory may overlap THREADSAFE.

Parameters
[out]dstMemory destination.
[in]srcMemory source.
[in]sizeNumber of bytes to be moved.

◆ MemCopyType()

MAXON_ATTRIBUTE_FORCE_INLINE void maxon::MemCopyType ( T *  dst,
const T *  src,
Int  cnt 
)

Copies the content of a datatype to another of the same kind source and destination memory must not overlap THREADSAFE.

Parameters
[out]dstDestination address of datatype.
[in]srcSource address of datatype.
[in]cntNumber of elements to be copied (>1 e.g. for arrays), can be 0.

◆ MemMoveType()

MAXON_ATTRIBUTE_FORCE_INLINE void maxon::MemMoveType ( T *  dst,
const T *  src,
Int  cnt 
)

Moves the content of a datatype to another of the same kind source and destination memory may overlap THREADSAFE.

Parameters
[out]dstDestination address of datatype.
[in]srcSource address of datatype.
[in]cntNumber of elements to be copied (>1 e.g. for arrays), can be 0.

◆ ClearMem()

MAXON_ATTRIBUTE_FORCE_INLINE void maxon::ClearMem ( void *  mem,
Int  size,
UChar  value = 0 
)

Clears memory with pattern, if size >0. THREADSAFE.

Parameters
[out]memMemory.
[in]sizeNumber of bytes to be filled with pattern, must be greater or equal to 0.
[in]valueOptional, 1-byte value defining the pattern (default: 0)

◆ SecureClearMem()

MAXON_ATTRIBUTE_FORCE_INLINE void maxon::SecureClearMem ( volatile void *  mem,
Int  size,
UChar  value = 0 
)

Clears memory with pattern, if size >0. The compiler might remove calls to ClearMem during optimization when the memory is not read from afterwards. To securely clear the memory block use SecureClearMem. THREADSAFE.

Parameters
[out]memMemory.
[in]sizeNumber of bytes to be filled with pattern, must be greater or equal to 0.
[in]valueOptional, 1-byte value defining the pattern (default: 0)

◆ CompareMem()

MAXON_ATTRIBUTE_FORCE_INLINE Int maxon::CompareMem ( const void *  block1,
const void *  block2,
Int  size 
)

Compares two memory blocks THREADSAFE.

Parameters
[in]block1Address of first memory block.
[in]block2Address of second memory block.
[in]sizeNumber of bytes to compare, must be greater or equal to 0.
Returns
Zero, if the memory blocks match, or a value different from zero representing which is greater if they do not.

◆ ClearMemType()

MAXON_ATTRIBUTE_FORCE_INLINE void maxon::ClearMemType ( T *  data_ptr,
Int  cnt,
UChar  value = 0 
)

Clears memory of a datatype with pattern, if size >0. THREADSAFE.

Parameters
[out]data_ptrAddress of the datatype.
[in]cntNumber of elements t be filled with pattern (>1 e.g. for arrays), can be 0.
[in]value(optional) fill value.

◆ operator%() [1/20]

void maxon::operator% ( const Result< Bool > &  res,
Result< Bool > &  yieldResult 
)

◆ operator%() [2/20]

void maxon::operator% ( const Result< void > &  res,
Result< Bool > &  yieldResult 
)

◆ MAXON_REGISTRY() [25/60]

maxon::MAXON_REGISTRY ( DescriptionProcessor  ,
DescriptionProcessors  ,
"net.maxon.registry.descriptionprocessors"   
)

◆ MAXON_MEMBERTYPE_DETECTOR() [1/3]

maxon::MAXON_MEMBERTYPE_DETECTOR ( IsFidClass  ,
FidType  ,
std::false_type   
)

◆ ConvertKeyToDataPtr() [1/2]

std::enable_if<!IsFidClass<KEY>::value, typename std::conditional<STD_IS_REPLACEMENT(reference, KEY) || STD_IS_REPLACEMENT(const, KEY), ConstDataPtr, MoveDataPtr>::type>::type maxon::ConvertKeyToDataPtr ( KEY &&  key)

The ConvertKeyToDataPtr helper functions are used for functions which need to separate an template argument T&& between d FId<T, KEYTYPE> and a real datatype. e.g. DataDictionary::Get accepts 2 versions, one thing is the key itself, the other is FId with the keytype and the datatype. the implementation is now easy.

class X
{
DataDictionary _dict;
public:
template <typename T, typename KEY> void Set(KEY&& key, T&& data)
{
_dict.SetData(ConvertKeyToDataPtr<DataPtr, typename std::decay<T>::type>(std::forward<KEY>(key)), Data(std::forward<T>(data)));
}
template <typename T = void, typename KEY> typename std::conditional<STD_IS_REPLACEMENT(void, T), typename IsFidClass<KEY>::type, T>::type Get(KEY&& key)
{
using TT = typename std::conditional<STD_IS_REPLACEMENT(void, T), typename IsFidClass<KEY>::type, T>::type;
_dict.GetData(ConvertKeyToDataPtr<ConstDataPtr, TT>(std::forward<KEY>(key)));
return TT();
}
};
Set
#define Set(a0, a1, a2, a3, a4, a5)
Definition: Python-ast.h:586
key
PyObject * key
Definition: abstract.h:289
STD_IS_REPLACEMENT
#define STD_IS_REPLACEMENT(name,...)
Definition: compilerdetection.h:276
maxon::Classes::Get
const Class< R > & Get(const Id &cls)
Definition: objectbase.h:2073
maxon::ConvertKeyToDataPtr
std::enable_if<!IsFidClass< KEY >::value, typename std::conditional< STD_IS_REPLACEMENT(reference, KEY)||STD_IS_REPLACEMENT(const, KEY), ConstDataPtr, MoveDataPtr >::type >::type ConvertKeyToDataPtr(KEY &&key)
Definition: fid.h:380

◆ ConvertKeyToDataPtr() [2/2]

std::enable_if<IsFidClass<KEY>::value, ConstDataPtr>::type maxon::ConvertKeyToDataPtr ( KEY &&  key)

◆ TestRestriction()

RESTRICT maxon::TestRestriction ( T  y,
OverloadRank0   
)

◆ MAXON_MEMBERTYPE_DETECTOR() [2/3]

maxon::MAXON_MEMBERTYPE_DETECTOR ( GetRestrict  ,
RESTRICT_DICTIONARY_PROPS  ,
maxon::RESTRICT   
)

◆ IsSourceControlAvailable()

Bool maxon::IsSourceControlAvailable ( )

Controls a source control system, e.g. Perforce.

Returns
true if if system is available

◆ MAXON_ENUM_FLAGS() [11/33]

enum maxon::FILEFORMATDETECTIONFLAGS maxon::MAXON_ENUM_FLAGS ( FILEFORMATDETECTIONFLAGS  )

◆ MAXON_REGISTRY() [26/60]

maxon::MAXON_REGISTRY ( FileFormat  ,
FileFormats  ,
"net.maxon.registry.fileformats"   
)

Registry to register/iterate all available FileFormat implementations.

◆ MAXON_DECLARATION() [31/84]

maxon::MAXON_DECLARATION ( Class< FileFormat >  ,
FileFormatBaseClass  ,
"net.maxon.class.fileformatbase"   
)

This class should be added to your own image fileformat implementation. It implements default values for GetData() for FILEFORMATPROPERTIES of files.

◆ MAXON_DECLARATION() [32/84]

maxon::MAXON_DECLARATION ( Class< FileFormatDetectionCacheRef >  ,
FileFormatDetectionCacheClass  ,
"net.maxon.class.fileformatdetectioncache"   
)

◆ MAXON_ENUM_LIST() [22/95]

enum maxon::FILEFORMAT_PRIORITY maxon::MAXON_ENUM_LIST ( FILEFORMAT_PRIORITY  )

◆ operator+() [1/2]

FILEFORMAT_PRIORITY maxon::operator+ ( FILEFORMAT_PRIORITY  s1,
FILEFORMAT_PRIORITY  s2 
)

◆ operator-()

FILEFORMAT_PRIORITY maxon::operator- ( FILEFORMAT_PRIORITY  s1,
FILEFORMAT_PRIORITY  s2 
)

◆ MAXON_REGISTRY() [27/60]

maxon::MAXON_REGISTRY ( FileFormatHandler  ,
FileFormatHandlers  ,
"net.maxon.registry.fileformathandlers"   
)

Registry to register/iterate all available FileFormatHandler implementations.

◆ PrivateGetDataType() [7/17]

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

◆ MAXON_DECLARATION() [33/84]

maxon::MAXON_DECLARATION ( Class< HierarchyObjectRef<>>  ,
HierarchyObjectClass  ,
"net.maxon.class.hierarchyobject"   
)

◆ TraverseChildren() [1/2]

static Result<Bool> maxon::TraverseChildren ( const REFTYPE &  object,
const Delegate< Result< Bool >(const REFTYPE &object, const REFTYPE &parent, const ConstDataPtr &branchId, Int depth)> &  function,
const ConstDataPtr &  branchId = ConstDataPtr(),
Int  depth = Int(0) 
)
static

Helper function to traverse all children of the root object.

MediaStreamRef stream; // object with hierarchy to run through
BaseArray<MediaStreamRef> res;
TraverseChildren<MediaStreamRef>(stream,
[&res](const MediaStreamRef& child, const MediaStreamRef& parent, const ConstDataPtr& branch, Int depth) -> Result<Bool>
{
iferr_scope;
res.Append(child) iferr_return;
return true;
}) iferr_return;
stream
PyObject * stream
Definition: codecs.h:186
Parameters
[in]objectObject to iterate.
[in]functionFunction which is called for each object.
[in]branchIdThe branch.
[in]depthStart value for the depth level.
Returns
returns false if iteration should stop. otherwise true to continue.

◆ TraverseMeAndChildren() [1/2]

static Result<Bool> maxon::TraverseMeAndChildren ( const REFTYPE &  object,
const Delegate< Result< Bool >(const REFTYPE &object, const REFTYPE &parent, const ConstDataPtr &branchId, Int depth)> &  function,
const ConstDataPtr &  branchId = ConstDataPtr(),
Int  depth = Int(0) 
)
static

Helper function to traverse the given object with its children.

MediaStreamRef stream; // object with hierarchy to run through
BaseArray<MediaStreamRef> res;
TraverseMeAndChildren<MediaStreamRef>(stream,
[&res](const MediaStreamRef& child, const MediaStreamRef& parent, const ConstDataPtr& branch, Int depth) -> Result<Bool>
{
iferr_scope;
res.Append(child) iferr_return;
return true;
}) iferr_return;
Parameters
[in]objectObject to iterate.
[in]functionFunction which is called for each object.
[in]branchIdThe branch.
[in]depthStart value for the depth level.
Returns
returns false if iteration should stop. otherwise true to continue.

◆ TraverseChildren() [2/2]

static Result<Bool> maxon::TraverseChildren ( const REFTYPE &  t,
const ConstDataPtr &  branch,
const Delegate< Result< Bool >(const REFTYPE &child, const REFTYPE &parent, const ConstDataPtr &branch, Int depth)> &  func,
Int  depth 
)
static

Helper function to traverse all children of the root object t.

MediaStreamRef stream; // object with hierarchy to run through
BaseArray<MediaStreamRef> res;
TraverseChildren<MediaStreamRef>(stream, ConstDataPtr(),
[&res](const MediaStreamRef& child, const MediaStreamRef& parent, const ConstDataPtr& branch, Int depth) -> Result<Bool>
{
iferr_scope;
res.Append(child) iferr_return;
return true;
}, 0) iferr_return;
Parameters
[in]tobject to iterate.
[in]funcfunction which is called for each object.
Returns
returns false if iteration should stop. otherwise true to continue.

◆ TraverseMeAndChildren() [2/2]

static Result<Bool> maxon::TraverseMeAndChildren ( const REFTYPE &  t,
const REFTYPE &  parent,
const ConstDataPtr &  branch,
const Delegate< Result< Bool >(const REFTYPE &child, const REFTYPE &parent, const ConstDataPtr &branch, Int depth)> &  func,
Int  depth = 0 
)
static

Helper function to traverse all children of the root object t, but also the given object.

MediaStreamRef stream; // object with hierarchy to run through
BaseArray<MediaStreamRef> res;
TraverseMeAndChildren<MediaStreamRef>(stream, MediaStreamRef(), ConstDataPtr(),
[&res](const MediaStreamRef& child, const MediaStreamRef& parent, const ConstDataPtr& branch, Int depth) -> Result<Bool>
{
iferr_scope;
res.Append(child) iferr_return;
return true;
}) iferr_return;
Parameters
[in]tobject to iterate.
[in]funcfunction which is called for each object.
Returns
returns false if iteration should stop. otherwise true to continue.

◆ MAXON_ENUM_LIST() [23/95]

enum maxon::ASSET_UPDATE_POLICY maxon::MAXON_ENUM_LIST ( ASSET_UPDATE_POLICY  ,
"net.maxon.datatype.enum.asset_update_policy"   
)

◆ MAXON_ENUM_LIST() [24/95]

enum maxon::IOTIMEMODE maxon::MAXON_ENUM_LIST ( IOTIMEMODE  ,
"net.maxon.datatype.enum.iotimemode"   
)

◆ MAXON_ENUM_LIST() [25/95]

enum maxon::URLCOMPARE maxon::MAXON_ENUM_LIST ( URLCOMPARE  ,
"net.maxon.datatype.enum.urlcompare"   
)

◆ MAXON_ENUM_LIST() [26/95]

enum maxon::IODETECT maxon::MAXON_ENUM_LIST ( IODETECT  ,
"net.maxon.datatype.enum.iodetect"   
)

◆ MAXON_ENUM_FLAGS() [12/33]

enum maxon::OPENSTREAMFLAGS maxon::MAXON_ENUM_FLAGS ( OPENSTREAMFLAGS  ,
"net.maxon.datatype.enum.openstreamflags"   
)

◆ MAXON_ENUM_FLAGS() [13/33]

enum maxon::NORMALIZEFLAGS maxon::MAXON_ENUM_FLAGS ( NORMALIZEFLAGS  ,
"net.maxon.datatype.enum.normalizeflags"   
)

◆ MAXON_ENUM_FLAGS() [14/33]

enum maxon::IOATTRIBUTES UInt maxon::MAXON_ENUM_FLAGS ( IOATTRIBUTES  ,
"net.maxon.datatype.enum.ioattributes"   
)

◆ ConvertIoAttributes()

void maxon::ConvertIoAttributes ( IOATTRIBUTES &  attributes)

Converts an IOATTRIBUTES value between different operating systems. If there is no RWX bit set the R attribute will be set in Linux and OSX. The W bit is set if the read-only bit is not set. On Windows the read-only bit is set if at least one RWX bit is set and no W bit is set.

Parameters
[in,out]attributesAttributes to convert.

◆ MAXON_ENUM_FLAGS() [15/33]

enum maxon::IOSHOWINOSFLAGS maxon::MAXON_ENUM_FLAGS ( IOSHOWINOSFLAGS  ,
"net.maxon.datatype.enum.ioshowinosflags"   
)

◆ CreateMemoryFileWithSuffix()

Result<Url> maxon::CreateMemoryFileWithSuffix ( const String &  suffix = String())

CreateMemoryFileWithSuffix returns a url of a memory file to write into.

Parameters
[in]suffixOptional suffix for the memory file.
Returns
Url on success. this url can be used to write to.

◆ PrivateConsoleOutput()

Result<void> maxon::PrivateConsoleOutput ( const String &  str,
const SourceLocation &  loc,
WRITEMETA  level 
)

◆ MAXON_ENUM_FLAGS() [16/33]

enum maxon::MACHINESTATE maxon::MAXON_ENUM_FLAGS ( MACHINESTATE  )

◆ MAXON_DECLARATION() [34/84]

maxon::MAXON_DECLARATION ( Class< MachineRef >  ,
LocalMachineClass  ,
"net.maxon.class.localmachine"   
)

◆ MAXON_DATATYPE() [27/66]

maxon::MAXON_DATATYPE ( CreateObjectRefFunc  ,
"net.maxon.datatype.createobjectreffunc"   
)

◆ MAXON_REGISTRY() [28/60]

maxon::MAXON_REGISTRY ( CreateObjectRefFunc  ,
MachineImplementationFactories  ,
"net.maxon.registry.machineimplementationfactories"   
)

◆ MAXON_IMPLEMENTATION_SIMPLE_REGISTER() [2/5]

maxon::MAXON_IMPLEMENTATION_SIMPLE_REGISTER ( MapImpl< MAP >  )

◆ ToMapPtr()

const MapInterface<K, V>* maxon::ToMapPtr ( const MapInterface< K, V > &  map)

Returns a pointer to the map reference argument. This function is useful if you have to convert some map to a pointer to a MapInterface:

void Func(const MapInterface<Int, const String>* map);
HashMap<Int, String> myMap;
Func(ToMapPtr(myMap));
maxon::ToMapPtr
const MapInterface< K, V > * ToMapPtr(const MapInterface< K, V > &map)
Definition: map.h:923

For WritableMapInterface parameters, use ToWritableMapPtr instead.

See also
MapInterface.
Template Parameters
KType of keys of the map, this is deduced by the compiler.
VType of values of the map, this is deduced by the compiler.
Note
If the argument is a temporary (which usually is the case), the result will be a pointer to a temporary. Make sure that the pointer is used only within the lifetime of the temporary. For the above example, it suffices that Func uses the map only during its execution.

◆ ToWritableMapPtr()

WritableMapInterface<K, V>* maxon::ToWritableMapPtr ( WritableMapInterface< K, V > &  map)

Returns a pointer to the map reference argument. This function is useful if you have to convert some map to a pointer to a MapInterface:

void Func(WritableMapInterface<Int, String>* map);
HashMap<Int, String> myMap;
Func(ToWritableMapPtr(myMap));
maxon::ToWritableMapPtr
WritableMapInterface< K, V > * ToWritableMapPtr(WritableMapInterface< K, V > &map)
Definition: map.h:949

For non-modifiable map parameters, use ToMapPtr instead.

See also
MapInterface.
Template Parameters
KType of keys of the map, this is deduced by the compiler.
VType of values of the map, this is deduced by the compiler.
Note
If the argument is a temporary (which usually is the case), the result will be a pointer to a temporary. Make sure that the pointer is used only within the lifetime of the temporary. For the above example, it suffices that Func uses the map only during its execution.

◆ operator*() [1/5]

Col3<typename MultiplicativePromotion<T, S, STD_IS_REPLACEMENT(scalar, S)>::type, 1> maxon::operator* ( S  s,
const Col3< T, STR > &  v 
)

Multiplies each vector component by a scalar.

◆ PrivateGetDataType() [8/17]

Result<DataType> maxon::PrivateGetDataType ( Col3< T, 1 > **  ,
OverloadRank1   
)

◆ operator*() [2/5]

Col4<typename MultiplicativePromotion<T, S, STD_IS_REPLACEMENT(scalar, S)>::type, 1> maxon::operator* ( S  s,
const Col4< T, STR > &  v 
)

Multiplies each vector component by a scalar.

◆ PrivateGetDataType() [9/17]

Result<DataType> maxon::PrivateGetDataType ( Col4< T, 1 > **  ,
OverloadRank1   
)

◆ operator*() [3/5]

Vec3<typename MultiplicativePromotion<T, S, STD_IS_REPLACEMENT(scalar, S)>::type, 1> maxon::operator* ( S  s,
const Vec3< T, STR > &  v 
)

Multiplies each vector component by a scalar.

◆ PrivateGetDataType() [10/17]

Result<DataType> maxon::PrivateGetDataType ( Vec3< T, 1 > **  ,
OverloadRank1   
)

◆ operator*() [4/5]

Vec2<typename MultiplicativePromotion<T, S, STD_IS_REPLACEMENT(scalar, S)>::type, 1, SPACE> maxon::operator* ( S  s,
const Vec2< T, STR, SPACE > &  v 
)

Multiplies each vector component by a scalar.

◆ PrivateGetDataType() [11/17]

Result<DataType> maxon::PrivateGetDataType ( Vec2< T, 1, SPACE > **  ,
OverloadRank1   
)

◆ operator*() [5/5]

Vec4<typename MultiplicativePromotion<T, S, STD_IS_REPLACEMENT(scalar, S)>::type, 1> maxon::operator* ( S  s,
const Vec4< T, STR > &  v 
)

Multiplies each vector component by a scalar.

◆ PrivateGetDataType() [12/17]

Result<DataType> maxon::PrivateGetDataType ( Vec4< T, 1 > **  ,
OverloadRank1   
)

◆ PrivateGetDataType() [13/17]

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

◆ PrivateGetDataType() [14/17]

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

◆ PrivateGetDataType() [15/17]

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

◆ PrivateGetDataType() [16/17]

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

◆ PrivateGetDataType() [17/17]

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

◆ MAXON_REGISTRY() [29/60]

maxon::MAXON_REGISTRY ( DataDictionary  ,
ModuleVersionInfos  ,
"net.maxon.registry.moduleversioninfos"   
)

◆ PrivateConstRefNullValue()

MAXON_ATTRIBUTE_FORCE_INLINE const T& maxon::PrivateConstRefNullValue ( T *  ,
OverloadRank0   
)

◆ PrivateConstRefNullValueHelper() [1/3]

MAXON_ATTRIBUTE_FORCE_INLINE const T& maxon::PrivateConstRefNullValueHelper ( OverloadRank0  )

◆ PrivateConstRefNullValueHelper() [2/3]

MAXON_ATTRIBUTE_FORCE_INLINE NullValueDetector<const T&, &T::NullValue>::type maxon::PrivateConstRefNullValueHelper ( OverloadRank1  )

◆ PrivateConstRefNullValueHelper() [3/3]

MAXON_ATTRIBUTE_FORCE_INLINE NullValueDetector<const T&, &T::NullValueRef>::type maxon::PrivateConstRefNullValueHelper ( OverloadRank2  )

◆ PrivateNullValueHelper() [1/3]

MAXON_ATTRIBUTE_FORCE_INLINE T maxon::PrivateNullValueHelper ( OverloadRank0  )

◆ PrivateNullValueHelper() [2/3]

MAXON_ATTRIBUTE_FORCE_INLINE NullValueDetector<T, &T::NullValue>::type maxon::PrivateNullValueHelper ( OverloadRank1  )

◆ PrivateNullValueHelper() [3/3]

MAXON_ATTRIBUTE_FORCE_INLINE NullValueDetector<const T&, &T::NullValue>::type maxon::PrivateNullValueHelper ( OverloadRank1  )

◆ PrivateNullValueDispatcher() [1/3]

MAXON_ATTRIBUTE_FORCE_INLINE T maxon::PrivateNullValueDispatcher ( OverloadRank0  )

◆ PrivateNullValueDispatcher() [2/3]

MAXON_ATTRIBUTE_FORCE_INLINE SFINAEHelper<T, typename NullValueFunctions<typename std::decay<T>::type>::Default>::type maxon::PrivateNullValueDispatcher ( OverloadRank1  )

◆ PrivateNullValueDispatcher() [3/3]

MAXON_ATTRIBUTE_FORCE_INLINE std::enable_if<IsZeroInitialized<typename std::decay<T>::type>::value || STD_IS_REPLACEMENT(same, typename std::decay<T>::type, Generic), T>::type maxon::PrivateNullValueDispatcher ( OverloadRank2  )

◆ NullValue< void >()

MAXON_ATTRIBUTE_FORCE_INLINE void maxon::NullValue< void > ( )

◆ MAXON_ENUM_LIST() [27/95]

enum maxon::NULL_RETURN_REASON maxon::MAXON_ENUM_LIST ( NULL_RETURN_REASON  )

◆ PrivateGetNullReturnError()

ThreadReferencedError maxon::PrivateGetNullReturnError ( NULL_RETURN_REASON  reason)

◆ PrivateLogNullptrError() [1/2]

MAXON_ATTRIBUTE_FORCE_INLINE void maxon::PrivateLogNullptrError ( )

◆ PrivateLogNullptrError() [2/2]

MAXON_ATTRIBUTE_FORCE_INLINE Bool maxon::PrivateLogNullptrError ( Bool  result)

◆ PrivateNullReturnValue() [1/5]

MAXON_ATTRIBUTE_FORCE_INLINE T maxon::PrivateNullReturnValue ( NULL_RETURN_REASON  reason,
OverloadRank0   
)

◆ PrivateNullReturnValue() [2/5]

MAXON_ATTRIBUTE_FORCE_INLINE SFINAEHelper<T, typename NullValueFunctions<typename std::decay<T>::type>::Default>::type maxon::PrivateNullReturnValue ( NULL_RETURN_REASON  reason,
OverloadRank1   
)

◆ PrivateNullReturnValue() [3/5]

MAXON_ATTRIBUTE_FORCE_INLINE SFINAEHelper<T, typename NullValueFunctions<typename std::decay<T>::type>::ResultMarker>::type maxon::PrivateNullReturnValue ( NULL_RETURN_REASON  reason,
OverloadRank2   
)

◆ PrivateNullReturnValue() [4/5]

MAXON_ATTRIBUTE_FORCE_INLINE std::enable_if<STD_IS_REPLACEMENT(same, Id, typename std::decay<T>::type), T>::type maxon::PrivateNullReturnValue ( NULL_RETURN_REASON  reason,
OverloadRank3   
)

◆ PrivateNullReturnValue() [5/5]

MAXON_ATTRIBUTE_FORCE_INLINE std::enable_if<IsZeroInitialized<typename std::decay<T>::type>::value || STD_IS_REPLACEMENT(same, typename std::decay<T>::type, Generic), T>::type maxon::PrivateNullReturnValue ( NULL_RETURN_REASON  reason,
OverloadRank4   
)

◆ PrivateIncompleteNullReturnValue() [1/5]

MAXON_ATTRIBUTE_FORCE_INLINE T maxon::PrivateIncompleteNullReturnValue ( NULL_RETURN_REASON  reason,
OverloadRank0   
)

◆ PrivateIncompleteNullReturnValue() [2/5]

MAXON_ATTRIBUTE_FORCE_INLINE SFINAEHelper<T, typename NullValueFunctions<typename std::decay<T>::type>::Default>::type maxon::PrivateIncompleteNullReturnValue ( NULL_RETURN_REASON  reason,
OverloadRank1   
)

◆ PrivateIncompleteNullReturnValue() [3/5]

MAXON_ATTRIBUTE_FORCE_INLINE SFINAEHelper<T, typename NullValueFunctions<typename std::decay<T>::type>::ResultMarker>::type maxon::PrivateIncompleteNullReturnValue ( NULL_RETURN_REASON  reason,
OverloadRank2   
)

◆ PrivateIncompleteNullReturnValue() [4/5]

MAXON_ATTRIBUTE_FORCE_INLINE std::enable_if<STD_IS_REPLACEMENT(same, Id, typename std::decay<T>::type), T>::type maxon::PrivateIncompleteNullReturnValue ( NULL_RETURN_REASON  reason,
OverloadRank3   
)

◆ PrivateIncompleteNullReturnValue() [5/5]

MAXON_ATTRIBUTE_FORCE_INLINE std::enable_if<IsZeroInitialized<typename std::decay<T>::type>::value, T>::type maxon::PrivateIncompleteNullReturnValue ( NULL_RETURN_REASON  reason,
OverloadRank4   
)

◆ MAXON_DECLARATION() [35/84]

maxon::MAXON_DECLARATION ( ComponentDescriptor  ,
ObservableCombinerRunAllComponent  ,
"net.maxon.component.observablecombinerrunall"   
)

Implementation of CombinerInterface. Using this combiner ensures that all subscribers are called. The result of the last notification will be returned.

◆ MAXON_DECLARATION() [36/84]

maxon::MAXON_DECLARATION ( ComponentDescriptor  ,
ObservableCombinerRunAllBoolOrComponent  ,
"net.maxon.component.observablecombinerrunallboolor"   
)

Implementation of CombinerInterface. Using this combiner ensures that all subscribers are called. The result is combined by an OR operation.

◆ MAXON_DECLARATION() [37/84]

maxon::MAXON_DECLARATION ( ComponentDescriptor  ,
ObservableCombinerRunAllBoolUntilFalse  ,
"net.maxon.component.observablecombinerrunallbooluntilfalse"   
)

Implementation of CombinerInterface. The result is initialized with true and runs until the first false occurs.

◆ MAXON_DECLARATION() [38/84]

maxon::MAXON_DECLARATION ( ComponentDescriptor  ,
ObservableCombinerRunAllBoolUntilTrue  ,
"net.maxon.component.observablecombinerrunallbooluntiltrue"   
)

Implementation of CombinerInterface. The result is initialized with false and runs until the first true occurs.

◆ MAXON_DECLARATION() [39/84]

maxon::MAXON_DECLARATION ( ComponentDescriptor  ,
ObservableCombinerRunAllEnumFlagsOrComponent  ,
"net.maxon.component.observablecombinerrunallenumflagsor"   
)

Implementation of CombinerInterface. Using this combiner ensures that all subscribers are called. The result is combined by an OR operation.

◆ MAXON_DECLARATION() [40/84]

maxon::MAXON_DECLARATION ( ComponentDescriptor  ,
ObservableCombinerRunAllEnumFlags64OrComponent  ,
"net.maxon.component.observablecombinerrunallenumflags64or"   
)

Implementation of CombinerInterface. Using this combiner ensures that all subscribers are called. The result is combined by an OR operation. Use this for 64-bit-wide enums.

◆ MAXON_DECLARATION() [41/84]

maxon::MAXON_DECLARATION ( ComponentDescriptor  ,
ObservableCombinerRunAllAggregateErrorsComponent  ,
"net.maxon.component.observablecombinerrunallaggregateerrors"   
)

Implementation of CombinerInterface. Using this combiner ensures that all subscribers are called. All errors returned by the subscribers will be aggregated and returnd as AggregatedError.

◆ MAXON_DECLARATION() [42/84]

maxon::MAXON_DECLARATION ( Class< FunctionBaseRef >  ,
FunctionBaseClass  ,
"net.maxon.class.functionbase"   
)

◆ MAXON_DECLARATION() [43/84]

maxon::MAXON_DECLARATION ( Class< ObservableBaseRef >  ,
ObservableClass  ,
"net.maxon.class.observable"   
)

◆ MAXON_DECLARATION() [44/84]

maxon::MAXON_DECLARATION ( Class< ObserverObjectRef >  ,
ObserverObjectClass  ,
"net.maxon.class.observerobject"   
)

◆ MAXON_ENUM_LIST() [28/95]

enum maxon::NO_VALUE_TYPE maxon::MAXON_ENUM_LIST ( NO_VALUE_TYPE  )

◆ operator==() [2/8]

Bool maxon::operator== ( const Opt< T > &  lhs,
const Opt< T > &  rhs 
)

Returns true if both Opts have the same value or both have no value.

◆ operator==() [3/8]

Bool maxon::operator== ( const Opt< T > &  opt,
NO_VALUE_TYPE   
)

Returns true, if Opt contains no value.

◆ operator==() [4/8]

Bool maxon::operator== ( NO_VALUE_TYPE  ,
const Opt< T > &  opt 
)

◆ operator!=() [2/7]

Bool maxon::operator!= ( const Opt< T > &  opt,
NO_VALUE_TYPE   
)

Returns true, if Opt contains a value.

◆ operator!=() [3/7]

Bool maxon::operator!= ( NO_VALUE_TYPE  ,
const Opt< T > &  opt 
)

◆ MAXON_REGISTRY() [30/60]

maxon::MAXON_REGISTRY ( ParametricType  ,
ParametricTypes  ,
"net.maxon.registry.parametrictypes"   
)

◆ MAXON_ENUM_FLAGS() [17/33]

enum maxon::PARSERFLAGS maxon::MAXON_ENUM_FLAGS ( PARSERFLAGS  )

◆ MAXON_REGISTRY() [31/60]

maxon::MAXON_REGISTRY ( Class< ParserRef >  ,
ParserClasses  ,
"net.maxon.interface.registry.parserclasses"   
)

◆ MAXON_DECLARATION() [45/84]

maxon::MAXON_DECLARATION ( Class< ParserRef >  ,
ParserBaseClass  ,
"net.maxon.interface.parserclass.base"   
)

◆ atomic_try_cas32()

Bool maxon::atomic_try_cas32 ( Int32 volatile *  dst,
Int32  xchg,
Int32  cmp 
)

Atomic Compare And Swap: Exchange memory location content with new value if its equal to comparison value This function implicitly creates a memory barrier.

Parameters
[in,out]dstMemory location.
[in]xchgNew value.
[in]cmpComparison value.
Returns
True if successul, false if memory location wasn't changed.

◆ atomic_try_cas32HLE()

Bool maxon::atomic_try_cas32HLE ( Int32 volatile *  dst,
Int32  xchg,
Int32  cmp 
)

◆ atomic_swap_add8()

Char maxon::atomic_swap_add8 ( Char volatile *  dst,
Char  value 
)

Atomic Add: Add value to memory location content and return the previous value This function implicitly creates a memory barrier.

Parameters
[in,out]dstMemory location.
[in]valueValue to add.
Returns
Previous memory location content.

◆ atomic_swap_add16()

Int16 maxon::atomic_swap_add16 ( Int16 volatile *  dst,
Int16  value 
)

Atomic Add: Add value to memory location content and return the previous value This function implicitly creates a memory barrier.

Parameters
[in,out]dstMemory location.
[in]valueValue to add.
Returns
Previous memory location content.

◆ atomic_swap_add32()

Int32 maxon::atomic_swap_add32 ( Int32 volatile *  dst,
Int32  value 
)

Atomic Add: Add value to memory location content and return the previous value This function implicitly creates a memory barrier.

Parameters
[in,out]dstMemory location.
[in]valueValue to add.
Returns
Previous memory location content.

◆ atomic_swap8()

Char maxon::atomic_swap8 ( Char volatile *  dst,
Char  value 
)

Atomic Swap: Store a value and return the memory location's previous value This function implicitely creates a memory barrier.

Parameters
[in,out]dstMemory location.
[in]valueNew value.
Returns
Previous memory location content.

◆ atomic_swap16()

Int16 maxon::atomic_swap16 ( Int16 volatile *  dst,
Int16  value 
)

Atomic Swap: Store a value and return the memory location's previous value This function implicitely creates a memory barrier.

Parameters
[in,out]dstMemory location.
[in]valueNew value.
Returns
Previous memory location content.

◆ atomic_swap32()

Int32 maxon::atomic_swap32 ( Int32 volatile *  dst,
Int32  value 
)

Atomic Swap: Store a value and return the memory location's previous value This function implicitely creates a memory barrier.

Parameters
[in,out]dstMemory location.
[in]valueNew value.
Returns
Previous memory location content.

◆ atomic_try_cas64()

Bool maxon::atomic_try_cas64 ( Int64 volatile *  dst,
Int64  xchg,
Int64  cmp 
)

Atomic Compare And Swap: Exchange memory location content with new value if its equal to comparision value This function implicitely creates a memory barrier.

Parameters
[in,out]dstMemory location.
[in]xchgNew value.
[in]cmpComparison value.
Returns
True if successul, false if memory location wasn't changed.

◆ atomic_try_cas64HLE()

Bool maxon::atomic_try_cas64HLE ( Int64 volatile *  dst,
Int64  xchg,
Int64  cmp 
)

◆ atomic_try_cas128()

Bool maxon::atomic_try_cas128 ( Int64 volatile *  dst,
Int64  xchghi,
Int64  xchglo,
Int64  cmphi,
Int64  cmplo 
)

Atomic Compare And Swap: Exchange memory location content with new value if its equal to comparision value This function implicitely creates a memory barrier.

Parameters
[in,out]dstMemory location.
[in]xchghiUpper 64 bit of the new value.
[in]xchgloLower 64 bit of the new value.
[in]cmphiUpper 64 bit of the comparison value.
[in]cmploLower 64 bit of the comparison value.
Returns
True if successul, false if memory location wasn't changed.

◆ atomic_swap_add64()

Int64 maxon::atomic_swap_add64 ( Int64 volatile *  dst,
Int64  value 
)

Atomic Add: Add value to memory location content and return the previous value This function implicitly creates a memory barrier.

Parameters
[in,out]dstMemory location.
[in]valueValue to add.
Returns
Previous memory location content.

◆ atomic_swap64()

Int64 maxon::atomic_swap64 ( Int64 volatile *  dst,
Int64  value 
)

Atomic Swap: Store a value and return the memory location's previous value This function implicitly creates a memory barrier.

Parameters
[in,out]dstMemory location.
[in]valueNew value.
Returns
Previous memory location content.

◆ atomic_swap_or32()

Int32 maxon::atomic_swap_or32 ( Int32 volatile *  dst,
Int32  mask 
)

Atomic Or: Or value to memory location content and return the previous value This function implicitely creates a memory barrier.

Parameters
[in,out]dstMemory location.
[in]maskMask for bitwise or.
Returns
Previous memory location content.

◆ atomic_swap_and32()

Int32 maxon::atomic_swap_and32 ( Int32 volatile *  dst,
Int32  mask 
)

Atomic And: And value to memory location content and return the previous value This function implicitely creates a memory barrier.

Parameters
[in,out]dstMemory location.
[in]maskMask for bitwise and.
Returns
Previous memory location content.

◆ atomic_try_cas8()

Bool maxon::atomic_try_cas8 ( Char volatile *  dst,
Char  xchg,
Char  cmp 
)

Atomic Compare And Swap: Exchange memory location content with new value if its equal to comparison value This function implicitly creates a memory barrier.

Parameters
[in,out]dstMemory location.
[in]xchgNew value.
[in]cmpComparison value.
Returns
True if successul, false if memory location wasn't changed.

◆ atomic_try_cas16()

Bool maxon::atomic_try_cas16 ( Int16 volatile *  dst,
Int16  xchg,
Int16  cmp 
)

Atomic Compare And Swap: Exchange memory location content with new value if its equal to comparison value This function implicitly creates a memory barrier.

Parameters
[in,out]dstMemory location.
[in]xchgNew value.
[in]cmpComparison value.
Returns
True if successul, false if memory location wasn't changed.

◆ atomic_consume_load8()

Char maxon::atomic_consume_load8 ( Char volatile *  src)

Atomic load with consume memory order. If another thread has released a store on this location it is guaranteed that after a load with consume memory order that reads the value stored direct dependencies are synchronized (e.g. if the value is a pointer to a structure you can safely access the elements of the structure that have been written before the release). This means that unrelated loads following this method might be reordered by the compiler or the CPU and can be executed before it. For most cpu architectures this the same instruction as an ordinary load which implies no performance penalty compared to a load with relaxed memory order.

Parameters
[in]srcMemory location.
Returns
Read memory location content.

◆ atomic_consume_load16()

Int16 maxon::atomic_consume_load16 ( Int16 volatile *  src)

Atomic load with consume memory order. If another thread has released a store on this location it is guaranteed that after a load with consume memory order that reads the value stored direct dependencies are synchronized (e.g. if the value is a pointer to a structure you can safely access the elements of the structure that have been written before the release). This means that unrelated loads following this method might be reordered by the compiler or the CPU and can be executed before it. For most cpu architectures this the same instruction as an ordinary load which implies no performance penalty compared to a load with relaxed memory order.

Parameters
[in]srcMemory location.
Returns
Read memory location content.

◆ atomic_consume_load32()

Int32 maxon::atomic_consume_load32 ( Int32 volatile *  src)

Atomic load with consume memory order. If another thread has released a store on this location it is guaranteed that after a load with consume memory order that reads the value stored direct dependencies are synchronized (e.g. if the value is a pointer to a structure you can safely access the elements of the structure that have been written before the release). This means that unrelated loads following this method might be reordered by the compiler or the CPU and can be executed before it. For most cpu architectures this the same instruction as an ordinary load which implies no performance penalty compared to a load with relaxed memory order.

Parameters
[in]srcMemory location.
Returns
Read memory location content.

◆ atomic_consume_load64()

Int64 maxon::atomic_consume_load64 ( Int64 volatile *  src)

Atomic load with consume memory order. If another thread has released a store on this location it is guaranteed that after a load with consume memory order that reads the value stored direct dependencies are synchronized (e.g. if the value is a pointer to a structure you can safely access the elements of the structure that have been written before the release). This means that unrelated loads following this method might be reordered by the compiler or the CPU and can be executed before it. For most cpu architectures this the same instruction as an ordinary load which implies no performance penalty compared to a load with relaxed memory order.

Parameters
[in]srcMemory location.
Returns
Read memory location content.

◆ atomic_acquire_load8()

Char maxon::atomic_acquire_load8 ( Char volatile *  src)

Atomic load with acquire memory order. If another thread has released a store on this location it is guaranteed that after a load with acquire memory order all following loads will see the (relaxed) stores that preceeding the release. Furthermore subsequent loads or stores will not be speculatively executed before this load.

Parameters
[in]srcMemory location.
Returns
Read memory location content.

◆ atomic_acquire_load16()

Int16 maxon::atomic_acquire_load16 ( Int16 volatile *  src)

Atomic load with acquire memory order. If another thread has released a store on this location it is guaranteed that after a load with acquire memory order all following loads will see the (relaxed) stores that preceeding the release. Furthermore subsequent loads or stores will not be speculatively executed before this load.

Parameters
[in]srcMemory location.
Returns
Read memory location content.

◆ atomic_acquire_load32()

Int32 maxon::atomic_acquire_load32 ( Int32 volatile *  src)

Atomic load with acquire memory order. If another thread has released a store on this location it is guaranteed that after a load with acquire memory order all following loads will see the (relaxed) stores that preceeding the release. Furthermore subsequent loads or stores will not be speculatively executed before this load.

Parameters
[in]srcMemory location.
Returns
Read memory location content.

◆ atomic_acquire_load64()

Int64 maxon::atomic_acquire_load64 ( Int64 volatile *  src)

Atomic load with acquire memory order. If another thread has released a store on this location it is guaranteed that after a load with acquire memory order all following loads will see the (relaxed) stores that preceeding the release. Furthermore subsequent loads or stores will not be speculatively executed before this load.

Parameters
[in]srcMemory location.
Returns
Read memory location content.

◆ atomic_sequential_load8()

Char maxon::atomic_sequential_load8 ( Char volatile *  src)

Atomic load with sequentially consistent memory order.

Parameters
[in]srcMemory location.
Returns
Read memory location content.

◆ atomic_sequential_load16()

Int16 maxon::atomic_sequential_load16 ( Int16 volatile *  src)

Atomic load with sequentially consistent memory order.

Parameters
[in]srcMemory location.
Returns
Read memory location content.

◆ atomic_sequential_load32()

Int32 maxon::atomic_sequential_load32 ( Int32 volatile *  src)

Atomic load with sequentially consistent memory order.

Parameters
[in]srcMemory location.
Returns
Read memory location content.

◆ atomic_sequential_load64()

Int64 maxon::atomic_sequential_load64 ( Int64 volatile *  src)

Atomic load with sequentially consistent memory order.

Parameters
[in]srcMemory location.
Returns
Read memory location content.

◆ atomic_release_store8()

void maxon::atomic_release_store8 ( Char volatile *  dst,
Char  value 
)

Atomic store with release memory order. As soon as another thread reads on this location and obtains the stored value it is guaranteed that all prior (relaxed) stores are visible to it.

Parameters
[in]dstMemory location.
[in]valueValue to be stored.

◆ atomic_release_store16()

void maxon::atomic_release_store16 ( Int16 volatile *  dst,
Int16  value 
)

Atomic store with release memory order. As soon as another thread reads on this location and obtains the stored value it is guaranteed that all prior (relaxed) stores are visible to it.

Parameters
[in]dstMemory location.
[in]valueValue to be stored.

◆ atomic_release_store32()

void maxon::atomic_release_store32 ( Int32 volatile *  dst,
Int32  value 
)

Atomic store with release memory order. As soon as another thread reads on this location and obtains the stored value it is guaranteed that all prior (relaxed) stores are visible to it.

Parameters
[in]dstMemory location.
[in]valueValue to be stored.

◆ atomic_release_store32HLE()

void maxon::atomic_release_store32HLE ( Int32 volatile *  dst,
Int32  value 
)

◆ atomic_release_store64()

void maxon::atomic_release_store64 ( Int64 volatile *  dst,
Int64  value 
)

Atomic store with release memory order. As soon as another thread reads on this location and obtains the stored value it is guaranteed that all prior (relaxed) stores are visible to it.

Parameters
[in]dstMemory location.
[in]valueValue to be stored.

◆ atomic_release_store64HLE()

void maxon::atomic_release_store64HLE ( Int64 volatile *  dst,
Int64  value 
)

◆ atomic_sequential_store8()

void maxon::atomic_sequential_store8 ( Char volatile *  dst,
Char  value 
)

Atomic store with sequentially consistent memory order.

Parameters
[in]dstMemory location.
[in]valueValue to be stored.

◆ atomic_sequential_store16()

void maxon::atomic_sequential_store16 ( Int16 volatile *  dst,
Int16  value 
)

Atomic store with sequentially consistent memory order.

Parameters
[in]dstMemory location.
[in]valueValue to be stored.

◆ atomic_sequential_store32()

void maxon::atomic_sequential_store32 ( Int32 volatile *  dst,
Int32  value 
)

Atomic store with sequentially consistent memory order.

Parameters
[in]dstMemory location.
[in]valueValue to be stored.

◆ atomic_sequential_store64()

void maxon::atomic_sequential_store64 ( Int64 volatile *  dst,
Int64  value 
)

Atomic store with sequentially consistent memory order.

Parameters
[in]dstMemory location.
[in]valueValue to be stored.

◆ MAXON_DECLARATION() [46/84]

maxon::MAXON_DECLARATION ( Class< ProgressRef >  ,
ProgressObject  ,
"net.maxon.image.class.mediasessionprogressobject"   
)

◆ MAXON_IMPLEMENTATION_SIMPLE_REGISTER() [3/5]

maxon::MAXON_IMPLEMENTATION_SIMPLE_REGISTER ( SetImpl< SET >  )

◆ ToSetPtr()

const SetInterface<T>* maxon::ToSetPtr ( const SetInterface< T > &  set)

Returns a pointer to the set reference argument. This function is useful if you have to convert some set to a pointer to a SetInterface:

void Func(const SetInterface<const Char>* set);
HashSet<Char> mySet;
Func(ToSetPtr(mySet));
maxon::ToSetPtr
const SetInterface< T > * ToSetPtr(const SetInterface< T > &set)
Definition: set.h:840

For WritableSetInterface parameters, use ToWritableSetPtr instead.

See also
SetInterface.
Template Parameters
TType of elements of the set, this is deduced by the compiler.
Note
If the argument is a temporary (which usually is the case), the result will be a pointer to a temporary. Make sure that the pointer is used only within the lifetime of the temporary. For the above example, it suffices that Func uses the set only during its execution.

◆ ToWritableSetPtr()

WritableSetInterface<T>* maxon::ToWritableSetPtr ( WritableSetInterface< T > &  set)

Returns a pointer to the set reference argument. This function is useful if you have to convert some set to a pointer to a SetInterface:

void Func(WritableSetInterface<const Char>* set);
HashSet<Char> mySet;
Func(ToWritableSetPtr(mySet));
maxon::ToWritableSetPtr
WritableSetInterface< T > * ToWritableSetPtr(WritableSetInterface< T > &set)
Definition: set.h:865

For non-modifiable set parameters, use ToSetPtr instead.

See also
SetInterface.
Template Parameters
TType of elements of the set, this is deduced by the compiler.
Note
If the argument is a temporary (which usually is the case), the result will be a pointer to a temporary. Make sure that the pointer is used only within the lifetime of the temporary. For the above example, it suffices that Func uses the set only during its execution.

◆ MAXON_ENUM_LIST() [29/95]

enum maxon::ACCESSLEVEL maxon::MAXON_ENUM_LIST ( ACCESSLEVEL  )

◆ LoadVector4f32() [1/8]

Vector4f32 maxon::LoadVector4f32 ( const Vector64 &  v,
Float64  w,
Bool  aligned 
)

◆ LoadVector4f32() [2/8]

Vector4f32 maxon::LoadVector4f32 ( const Vector32 &  v,
Float32  w,
Bool  aligned 
)

◆ LoadVector4f32() [3/8]

Vector4f32 maxon::LoadVector4f32 ( const Vector4d64 &  v,
Bool  aligned 
)

◆ LoadVector4f32() [4/8]

Vector4f32 maxon::LoadVector4f32 ( const Vector4d32 &  v,
Bool  aligned 
)

◆ LoadVector4f32() [5/8]

Vector4f32 maxon::LoadVector4f32 ( const Color64 &  v,
Float64  w,
Bool  aligned 
)

◆ LoadVector4f32() [6/8]

Vector4f32 maxon::LoadVector4f32 ( const Color32 &  v,
Float32  w,
Bool  aligned 
)

◆ LoadVector4f32() [7/8]

Vector4f32 maxon::LoadVector4f32 ( const ColorA64 &  v,
Bool  aligned 
)

◆ LoadVector4f32() [8/8]

Vector4f32 maxon::LoadVector4f32 ( const ColorA32 &  v,
Bool  aligned 
)

◆ _mm_crc32_u64()

UInt64 maxon::_mm_crc32_u64 ( UInt64  c,
UInt64  d 
)

This file defines the intrinsics that are not available from the compiler.

◆ _mm_crc32_u32()

unsigned int maxon::_mm_crc32_u32 ( UInt32  c,
UInt32  d 
)

◆ _mm_crc32_u8()

unsigned int maxon::_mm_crc32_u8 ( UInt32  c,
UChar  d 
)

◆ CastToVector4f32()

MAXON_ATTRIBUTE_FORCE_INLINE Vector4f32 maxon::CastToVector4f32 ( const Vector4i32 &  a)

Casts a Vector4i32 to a Vector4f32 vector.

Returns
A Vector4f32 vector.

◆ ConvertToVector4f32() [1/3]

MAXON_ATTRIBUTE_FORCE_INLINE Vector4f32 maxon::ConvertToVector4f32 ( const Vector4i32 &  a)

Converts a Vector4i32 to a Vector4f32 vector.

Returns
A Vector4f32 vector.

◆ CastToVector4i32()

MAXON_ATTRIBUTE_FORCE_INLINE Vector4i32 maxon::CastToVector4i32 ( const Vector4f32 &  a)

Casts a Vector4f32 to a Vector4i32 vector.

Returns
A Vector4i32 vector.

◆ ConvertToVector4i32()

MAXON_ATTRIBUTE_FORCE_INLINE Vector4i32 maxon::ConvertToVector4i32 ( const Vector4f32 &  a)

Converts a Vector4f32 to a Vector4i32 vector.

Returns
A Vector4i32 vector.

◆ ConvertToVector4f32() [2/3]

MAXON_ATTRIBUTE_FORCE_INLINE Vector4f32 maxon::ConvertToVector4f32 ( const Vector2f64 &  a,
const Vector2f64 &  b 
)

Converts two Vector2f64 to a Vector4f32 vector.

Returns
A Vector4f32 vector.

◆ ConvertToVector4f32() [3/3]

MAXON_ATTRIBUTE_FORCE_INLINE Vector4f32 maxon::ConvertToVector4f32 ( const Vector2f64 &  a)

Converts one Vector2f64 to a Vector4f32 vector.

Returns
A Vector4f32 vector. The two lower values are the converted members from the source vector, the two upper values are zero.

◆ MAXON_REGISTRY() [32/60]

maxon::MAXON_REGISTRY ( StreamConversionFactory  ,
StreamConversions  ,
"net.maxon.registry.streamconversions"   
)

◆ MAXON_DATATYPE() [28/66]

maxon::MAXON_DATATYPE ( ConversionTestSet  ,
"net.maxon.datatype.conversiontestset"   
)

◆ MAXON_REGISTRY() [33/60]

maxon::MAXON_REGISTRY ( Factory< BaseArray< DataDictionary >()>  ,
StreamConversionTests  ,
"net.maxon.registry.streamconversiontests"   
)

DataDictionary used STREAMCONVERSIONTEST to for the tests.

◆ AddConversionTestSetting() [1/4]

Result<void> maxon::AddConversionTestSetting ( MAXON_SOURCE_LOCATION_DECLARATION  ,
BaseArray< DataDictionary > &  resultArray,
const Block< const ConversionTestSet > &  set,
const Block< const Char > &  srcData,
const Block< const Char > &  compareData = Block< const Char >(),
Bool  forbidLargeTest = false 
)

Helper function to add crypto tests.

◆ AddConversionTestSetting() [2/4]

Result<void> maxon::AddConversionTestSetting ( MAXON_SOURCE_LOCATION_DECLARATION  ,
BaseArray< DataDictionary > &  resultArray,
const Block< const ConversionTestSet > &  set,
const Block< const Utf32Char > &  srcData,
const Block< const Char > &  compareData = Block< const Char >(),
Bool  forbidLargeTest = false 
)

◆ AddConversionTestSetting() [3/4]

Result<void> maxon::AddConversionTestSetting ( MAXON_SOURCE_LOCATION_DECLARATION  ,
BaseArray< DataDictionary > &  resultArray,
const Block< const ConversionTestSet > &  set,
const Block< const Char > &  srcData,
const Block< const Utf32Char > &  compareData = Block< const Utf32Char >(),
Bool  forbidLargeTest = false 
)

◆ AddConversionTestSetting() [4/4]

Result<void> maxon::AddConversionTestSetting ( MAXON_SOURCE_LOCATION_DECLARATION  ,
BaseArray< DataDictionary > &  resultArray,
const Block< const ConversionTestSet > &  set,
const Block< const Utf32Char > &  srcData,
const Block< const Utf32Char > &  compareData = Block< const Utf32Char >(),
Bool  forbidLargeTest = false 
)

◆ ConvertStreamConversionRef()

Factory<TO(const DataDictionary&)>& maxon::ConvertStreamConversionRef ( FROM &  obj)

◆ MAXON_DECLARATION() [47/84]

maxon::MAXON_DECLARATION ( Class< StreamConversionRef >  ,
StreamConversionBaseClass  ,
"net.maxon.class.streamconversionbase"   
)

◆ ToString() [1/2]

std::enable_if<STD_IS_REPLACEMENT(enum, T), String>::type maxon::ToString ( const T &  object,
const FormatStatement *  formatStatement,
Bool  checkDataType = true 
)

◆ MAXON_ENUM_FLAGS() [18/33]

enum maxon::EXECUTEPROGRAMFLAGS maxon::MAXON_ENUM_FLAGS ( EXECUTEPROGRAMFLAGS  )

◆ MAXON_ENUM_LIST() [30/95]

enum maxon::EXECUTEPROGRAMCALLBACK maxon::MAXON_ENUM_LIST ( EXECUTEPROGRAMCALLBACK  )

◆ MAXON_ENUM_LIST() [31/95]

enum maxon::WAIT_PROCESS_RESULT maxon::MAXON_ENUM_LIST ( WAIT_PROCESS_RESULT  )

◆ MAXON_DECLARATION() [48/84]

maxon::MAXON_DECLARATION ( Class< SystemProcessObjectRef >  ,
SystemProcessObjectClass  ,
"net.maxon.class.systemprocessobject"   
)

◆ MAXON_ENUM_LIST() [32/95]

enum maxon::THREADPRIORITY Int16 maxon::MAXON_ENUM_LIST ( THREADPRIORITY  )

◆ MAXON_ENUM_FLAGS() [19/33]

enum maxon::WAITMODE maxon::MAXON_ENUM_FLAGS ( WAITMODE  )

◆ MAXON_ENUM_LIST() [33/95]

enum maxon::THREADTYPE maxon::MAXON_ENUM_LIST ( THREADTYPE  )

◆ MAXON_DATATYPE() [29/66]

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

◆ TupleGet() [1/3]

auto TupleGet ( const Tuple< TYPES ... > &  tup) -> const typename ParameterPack<TYPES...>::template At<I>::type&

TupleGet is the equivalent of std::get. It returns the element at index I.

Example:

Tuple<Int, String> tup(1, "Hello"_s);
Int i = TupleGet<0>(tup);
CString s = TupleGet<1>(tup);
s
PyObject PyObject const char const char char ** s
Definition: bytesobject.h:60

Note that the index must be a compile-time constant.

If tup is bound to a const&, the element will be returned by const&. If tup is bound to a &, the element will be returned by &. If tup is bound to a &&, the element will be returned by &&.

Template Parameters
IThe index of the element that should be returned.
Parameters
[in]tupThe tuple from which to get the element.
Returns
The returned element.

A TupleGet overload that uses a type to select a unique element. The type must be unique in the given tuple, otherwise a compile-time error will occur.

Example:

Tuple<Int, String> tup(1, "Hello"_s);
Int i = TupleGet<Int>(tup);
CString s = TupleGet<String>(tup);

Note that the index must be a compile-time constant.

If tup is bound to a const&, the element will be returned by const&. If tup is bound to a &, the element will be returned by &. If tup is bound to a &&, the element will be returned by &&.

Template Parameters
ELEMENTTYPEThe type of the element that should be returned (must be unique in the tuple).
Parameters
[in]tupThe tuple from which to get the element.
Returns
The returned element.

◆ TupleGet() [2/3]

auto TupleGet ( Tuple< TYPES ... > &  tup) -> typename ParameterPack<TYPES...>::template At<I>::type&

◆ TupleGet() [3/3]

auto TupleGet ( Tuple< TYPES ... > &&  tup) -> typename ParameterPack<TYPES...>::template At<I>::type&&

◆ TupleExpand() [1/3]

auto maxon::TupleExpand ( const Tuple< TYPES ... > &  tup,
F &&  func 
) -> decltype(maxon::details::ExpandSeqHelperConst(tup, std::forward<F>(func), std::make_index_sequence<sizeof...(TYPES)>()))

TupleExpand unpacks values from a tuple and passes them as arguments to a function, i.e. a function F(TYPES ...) is called with the elements of a Tuple<TYPES ...>.

If tup is bound to a const&, it's elements will be passed by const&. If tup is bound to a &, it's elements will be passed by &. If tup is bound to a &&, it's elements will be passed by &&.

Parameters
[in]tupThe expanded tuple.
[in]funcThe function accepting the tuple elements as arguments.
Returns
The return value of the called function.

◆ TupleExpand() [2/3]

auto maxon::TupleExpand ( Tuple< TYPES ... > &  tup,
F &&  func 
) -> decltype(maxon::details::ExpandSeqHelper(tup, std::forward<F>(func), std::make_index_sequence<sizeof...(TYPES)>()))

◆ TupleExpand() [3/3]

auto maxon::TupleExpand ( Tuple< TYPES ... > &&  tup,
F &&  func 
) -> decltype(maxon::details::ExpandSeqHelper(std::move(tup), std::forward<F>(func), std::make_index_sequence<sizeof...(TYPES)>()))

◆ ToTuple()

auto maxon::ToTuple ( TYPES &&...  args) -> Tuple<typename std::decay<TYPES>::type ...>

ToTuple is a helper function that takes a variable number of arguments and returns them as a tuple. This function is decaying, so any const or reference modifiers will be stripped from the arguments, i.e. if a const T& is passed in, it will be stored as a plain T. ToTuple is the equivalent of std::make_tuple for std::tuple.

Parameters
[in]argsElements of the created tuple.
Returns
A tuple containing args ... .

◆ Tie()

auto maxon::Tie ( TYPES &...  args) -> Tuple<TYPES& ...>

Tie takes a variable number of references and returns them packed as tuple of references. This allows to leverage useful tuple operations, i.e. element-wise converting assignment. Tie is the equivalent of std::tie for std::tuple.

The following example shows how to return a tuple of values from a function and use Tie to simplify the unpacking:

Int a; Int b;
Tie(a, b) = FunctionReturningTuple(x, y, z);
// ... is equivalent to ...
Int a; Int b;
Tuple<Int, Int> result = FunctionReturningTuple(x, y, z);
a = result.first;
b = result.second;
// ... is equivalent to ...
Int a; Int b;
FunctionWithRefOutArgs(x, y, z, a, b); // pass a, b as ref out arguments
result
PyObject PyObject * result
Definition: abstract.h:43
x
PyObject * x
Definition: bytesobject.h:38
maxon::Tie
auto Tie(TYPES &... args) -> Tuple< TYPES &... >
Definition: tuple.h:1177
Parameters
[in]argsA variable number of references.
Returns
A tuple containing args& ... .

◆ ToForwardTuple()

auto maxon::ToForwardTuple ( TYPES &&...  args) -> Tuple<TYPES&& ...>

ToForwardTuple is similar to Tie, but instead of binding arguments to an lvalue reference, it forwards them. This is useful when forwarding arguments into a function that accepts a tuple. Tie is the equivalent of std::forward_as_tuple for std::tuple.

Parameters
[in]argsA variable number of references.
Returns
A tuple containing args&& ... .

◆ TupleForEach() [1/3]

void maxon::TupleForEach ( const Tuple< TYPES ... > &  tup,
F &&  func 
)

TupleForEach applies the given function to all elements of the tuple. This means F must be callable with all element types. This can be accomplished with a function template, or a function object with several overloads.

Parameters
[in]tupThe iterated tuple.
[in]funcA callable object, accepting each tuple element as argument.

◆ TupleForEach() [2/3]

void maxon::TupleForEach ( Tuple< TYPES ... > &  tup,
F &&  func 
)

◆ TupleForEach() [3/3]

void maxon::TupleForEach ( Tuple< TYPES ... > &&  tup,
F &&  func 
)

◆ TupleFold() [1/3]

auto maxon::TupleFold ( const Tuple< TYPES ... > &  tup,
const V &  initialValue,
F &&  func 
) -> V

TupleFold works similar to std::accumulate. It applies a binary function to an initial value and the first element of the tuple, then repeats that for the result and the next element, and so on. The last result is returned by the function. Example:

Tuple<Int, Int, Int> tup1(1, 10, 100);
Int res1 = TupleFold<Int>(t1, 1000, [] (Int a, Int b) { return a + b; });
// res1 is 1000 + 1 + 10 + 100
Tuple<String, String> tup2("Hello"_s, "World"_s);
Int res2 = TupleFold(t2, "Result:"_s, [] (String a, String b) { return a.Append(b); });
// res2 is "Result: Hello World"
maxon::TupleFold
auto TupleFold(const Tuple< TYPES ... > &tup, const V &initialValue, F &&func) -> V
Definition: tuple.h:1242
Parameters
[in]tupThe folded tuple.
[in]initialValueThe initial value.
[in]funcA function accepting each tuple element as arguments.
Returns
The folded result value.

◆ TupleFold() [2/3]

auto maxon::TupleFold ( Tuple< TYPES ... > &  tup,
const V &  initialValue,
F &&  func 
) -> V

◆ TupleFold() [3/3]

auto maxon::TupleFold ( Tuple< TYPES ... > &&  tup,
const V &  initialValue,
F &&  func 
) -> V

◆ GetTypeName()

MAXON_ATTRIBUTE_FORCE_INLINE Id maxon::GetTypeName ( )

Returns a compiler-generated name for type T. This is based on the compiler-specific macros FUNCSIG or PRETTY_FUNCTION (see MAXON_FUNCTION_SIGNATURE).

Template Parameters
TA type.
Returns
Compiled-generated name for T.

◆ MAXON_ENUM_LIST() [34/95]

enum maxon::BASE_DIMENSION maxon::MAXON_ENUM_LIST ( BASE_DIMENSION  )

◆ MAXON_REGISTRY() [34/60]

maxon::MAXON_REGISTRY ( Dimension  ,
Dimensions  ,
"net.maxon.registry.dimensions"   
)

◆ MAXON_REGISTRY() [35/60]

maxon::MAXON_REGISTRY ( Unit  ,
Units  ,
"net.maxon.registry.units"   
)

◆ MAXON_ENUM_FLAGS() [20/33]

enum maxon::URLFILECACHEFLAGS maxon::MAXON_ENUM_FLAGS ( URLFILECACHEFLAGS  )

◆ MoveFromWithFilter()

Result<void> maxon::MoveFromWithFilter ( DST &  dst,
SRC &  src,
const FN &  filter 
)

◆ GetPrintableString()

String maxon::GetPrintableString ( JNIEnv *  env,
const jstring &  val 
)

◆ ToString() [2/2]

static String maxon::ToString ( JNIEnv *  env,
const jstring &  str 
)
static

◆ CreateCopyWrapper()

Result<CopyWrapper<typename std::decay<T>::type> > maxon::CreateCopyWrapper ( T &&  src)

Creates a CopyWrapper object based on the source object

auto wrapped = CreateCopyWrapper(delegate) iferr_return;
auto lambda =
[callbackWrapper = std::move(wrapped)]() -> Result<void>
{
iferr_scope;
...
auto& callback = callbackWrapper.Get() iferr_return;
callback(...);
...
};
maxon::CreateCopyWrapper
Result< CopyWrapper< typename std::decay< T >::type > > CreateCopyWrapper(T &&src)
Definition: movecopywrapper.h:138
callback
PyObject * callback
Definition: weakrefobject.h:59
Parameters
[in]srcObject to be copied or moved into the wrapper.
Template Parameters
TType of object to wrapped.
Returns
Wrapped object on success.

◆ NewObjT()

ResultPtr<T> maxon::NewObjT ( ARGS &&...  args)

Creates an object with constructor parameters (using new or T::Alloc, depending on the type). This does not throw any kind of exception, it returns null if the allocation fails. NewObj does not clear the memory. Usage: MyType* x = NewObj(MyType, optional constructor parameters);

Note
Creating a template object will not compile if the template contains a comma, e.g. NewObj(MyType<1,2>). This is due to the nature of how the preprocessor works. To make it work either use NewObjT<>() or declare an alias using MyAllocType = MyType<1,2>; and then pass MyAllocType for the allocation itself.
NewObjT does not support objects which might throw exceptions. THREADSAFE.
Parameters
[in]argsAdditional constructor parameters.
Template Parameters
TType of object.
ARGSAdditional constructor parameter types.
Returns
Pointer to object (null if allocation failed)

◆ DeleteConstPtrObj()

MAXON_ATTRIBUTE_FORCE_INLINE void maxon::DeleteConstPtrObj ( T *  o)

Deletes an object. This calls the destructor and frees memory afterwards. Normally you should use DeleteObj(). This variant should be used only in the rare case when the object pointer is a constant so that it can't be set to nullptr.

Note
DeleteConstPtrObj does not support objects which might throw exceptions. THREADSAFE.
Parameters
[in]oObject pointer (can be nullptr)

◆ MAXON_ENUM_LIST() [35/95]

enum maxon::ERROR_OK maxon::MAXON_ENUM_LIST ( ERROR_OK  )

◆ MAXON_ENUM_LIST() [36/95]

enum maxon::ERROR_FAILED maxon::MAXON_ENUM_LIST ( ERROR_FAILED  )

◆ MAXON_ENUM_LIST() [37/95]

enum maxon::ERROR_TYPE maxon::MAXON_ENUM_LIST ( ERROR_TYPE  )

◆ CreateErrorPtr()

const Error* maxon::CreateErrorPtr ( MAXON_SOURCE_LOCATION_DECLARATION  ,
ERROR_TYPE  type 
)
private

CreateErrorPtr is declared as a pure function to allow the compiler to eliminate the call if the error isn't used anywhere. This might happen when iferr is used for error detection only (and the ThreadReferencedError isn't used anywhere).

iferr (Int* ptr = array.Append(42))
return false;
obj._valueIsAt = ptr;
obj
PyObject * obj
Definition: complexobject.h:60
iferr
#define iferr(...)
Definition: errorbase.h:388
ptr
char ** ptr
Definition: pycore_dtoa.h:13

◆ CreateError()

ThreadReferencedError maxon::CreateError ( MAXON_SOURCE_LOCATION_DECLARATION  ,
ERROR_TYPE  type 
)

This function can be used in low-level header files which cannot include error.h, but have to create errors. It can and should only be used in a return statement of a function returning a Result value.

Example:

return CreateError(MAXON_SOURCE_LOCATION, ERROR_TYPE::ILLEGAL_ARGUMENT);
MAXON_SOURCE_LOCATION
#define MAXON_SOURCE_LOCATION
Definition: memoryallocationbase.h:67
maxon::ERROR_TYPE::ILLEGAL_ARGUMENT
@ ILLEGAL_ARGUMENT
Create an IllegalArgumentError.
maxon::CreateError
ThreadReferencedError CreateError(MAXON_SOURCE_LOCATION_DECLARATION, ERROR_TYPE type)
Definition: resultbase.h:482

is equivalent to

return IllegalArgumentError(MAXON_SOURCE_LOCATION);

but the former doesn't require to include error.h.

The returned error will be referenced by the current thread.

Parameters
[in]allocLocationUse MAXON_SOURCE_LOCATION as argument so that file and line information is set for the error.
[in]typeThe desired error class.
Returns
Error object of the given class.

◆ PrivateSystemSetCurrentError() [1/2]

const Error* maxon::PrivateSystemSetCurrentError ( const Error &  error)

◆ PrivateSystemSetCurrentError() [2/2]

const Error* maxon::PrivateSystemSetCurrentError ( Error &&  error)

◆ PrivateSetError()

void maxon::PrivateSetError ( Error &  dest,
const Error *  src 
)

◆ MAXON_MEMBERTYPE_DETECTOR() [3/3]

maxon::MAXON_MEMBERTYPE_DETECTOR ( IsForwardRef  ,
IsForwardRef  ,
std::false_type   
)

◆ operator%() [3/20]

MAXON_ATTRIBUTE_FORCE_INLINE auto maxon::operator% ( const ResultOk< T > &  rv,
ThreadReferencedError &  err 
) -> decltype(rv.GetValue())

◆ operator%() [4/20]

MAXON_ATTRIBUTE_FORCE_INLINE T maxon::operator% ( ResultOk< T > &&  rv,
ThreadReferencedError &  err 
)

◆ operator%() [5/20]

MAXON_ATTRIBUTE_FORCE_INLINE T& maxon::operator% ( ResultOk< T & > &&  rv,
ThreadReferencedError &  err 
)

◆ operator%() [6/20]

MAXON_ATTRIBUTE_FORCE_INLINE void maxon::operator% ( ResultOk< void > &&  rv,
ThreadReferencedError &  err 
)

◆ operator%() [7/20]

MAXON_ATTRIBUTE_FORCE_INLINE auto maxon::operator% ( const ResultOk< T > &  rv,
maxon::details::ResultOkError &  err 
) -> decltype(rv.GetValue())

◆ operator%() [8/20]

MAXON_ATTRIBUTE_FORCE_INLINE T maxon::operator% ( ResultOk< T > &&  rv,
maxon::details::ResultOkError &  err 
)

◆ operator%() [9/20]

MAXON_ATTRIBUTE_FORCE_INLINE T& maxon::operator% ( ResultOk< T & > &&  rv,
maxon::details::ResultOkError &  err 
)

◆ operator%() [10/20]

MAXON_ATTRIBUTE_FORCE_INLINE void maxon::operator% ( ResultOk< void > &&  rv,
maxon::details::ResultOkError &  err 
)

◆ operator%() [11/20]

MAXON_ATTRIBUTE_FORCE_INLINE auto maxon::operator% ( const Result< T > &  rv,
ThreadReferencedError &  err 
) -> decltype(rv.GetValue())

◆ operator%() [12/20]

MAXON_ATTRIBUTE_FORCE_INLINE T maxon::operator% ( Result< T > &&  rv,
ThreadReferencedError &  err 
)

◆ operator%() [13/20]

MAXON_ATTRIBUTE_FORCE_INLINE T& maxon::operator% ( const Result< T & > &  rv,
ThreadReferencedError &  err 
)

◆ operator%() [14/20]

MAXON_ATTRIBUTE_FORCE_INLINE T& maxon::operator% ( Result< T & > &&  rv,
ThreadReferencedError &  err 
)

◆ operator%() [15/20]

MAXON_ATTRIBUTE_FORCE_INLINE void maxon::operator% ( const Result< void > &  rv,
ThreadReferencedError &  err 
)

◆ operator%() [16/20]

MAXON_ATTRIBUTE_FORCE_INLINE void maxon::operator% ( Result< void > &&  rv,
ThreadReferencedError &  err 
)

◆ operator%() [17/20]

MAXON_ATTRIBUTE_FORCE_INLINE T&& maxon::operator% ( ResultMemT< T > &&  ptr,
ThreadReferencedError &  err 
)

◆ operator%() [18/20]

MAXON_ATTRIBUTE_FORCE_INLINE const T& maxon::operator% ( const ResultMemT< T > &  ptr,
ThreadReferencedError &  err 
)

◆ operator%() [19/20]

MAXON_ATTRIBUTE_FORCE_INLINE T& maxon::operator% ( ResultRef< T >  ptr,
ThreadReferencedError &  err 
)

◆ SetSplashMessage()

void maxon::SetSplashMessage ( const String &  text)

◆ SetSplashImage()

void maxon::SetSplashImage ( const Url &  url)

◆ SetSplashStartBlocking()

void maxon::SetSplashStartBlocking ( )

◆ SetSplashShow()

void maxon::SetSplashShow ( Bool  show)

◆ DebugPrint()

static MAXON_ATTRIBUTE_FORCE_INLINE void maxon::DebugPrint ( const String &  str)
static

◆ FreeThreadedStuff()

static void maxon::FreeThreadedStuff ( )
static

◆ GetHResultError()

MAXON_ATTRIBUTE_FORCE_INLINE Error maxon::GetHResultError ( HRESULT  hr,
MAXON_SOURCE_LOCATION_DECLARATION   
)

◆ operator%() [20/20]

MAXON_ATTRIBUTE_FORCE_INLINE void maxon::operator% ( HRESULT  value,
ThreadReferencedError &  err 
)

◆ PropVariantToInt64()

MAXON_ATTRIBUTE_FORCE_INLINE Result<Int64> maxon::PropVariantToInt64 ( const PROPVARIANT &  vt)

Converts a windows VARIANT into a Int64 value with proper error handling.

◆ VariantToInt64()

MAXON_ATTRIBUTE_FORCE_INLINE Result<Int64> maxon::VariantToInt64 ( const VARIANT &  vt)

◆ PropVariantToUniversalDateTime()

MAXON_ATTRIBUTE_FORCE_INLINE Result<UniversalDateTime> maxon::PropVariantToUniversalDateTime ( const PROPVARIANT &  vt)

Converts a windows VARIANT into a DateTime value with proper error handling.

◆ VariantToUniversalDateTime()

MAXON_ATTRIBUTE_FORCE_INLINE Result<UniversalDateTime> maxon::VariantToUniversalDateTime ( const VARIANT &  vt)

◆ ConvertSystemTimeToUniversalDateTime()

UniversalDateTime maxon::ConvertSystemTimeToUniversalDateTime ( const SYSTEMTIME &  st)

◆ FiletimeToUnixTimestamp()

UInt64 maxon::FiletimeToUnixTimestamp ( const FILETIME &  ft)

Converts a FILETIME object to an unsigned integer which can be used when a unix timestamp is needed.

Do not cast a pointer to a FILETIME structure to either a ULARGE_INTEGER* or __int64* value because it can cause alignment faults on 64-bit Windows. See: https://msdn.microsoft.com/en-us/library/ms724284(VS.85).aspx

◆ ConvertFileTimeToUniversalDateTime()

static Result<UniversalDateTime> maxon::ConvertFileTimeToUniversalDateTime ( const FILETIME &  fd,
Bool  filetimeIsUtc 
)
static

Converts a FILETIME object to an UniversaleDateTime object. A FILETIME object can be in UTC or local. https://msdn.microsoft.com/en-us/library/windows/desktop/ms724290(v=vs.85).aspx

Parameters
[in]fdThe object to convert.

◆ ConvertUniversalDateTimeToSystemTime()

SYSTEMTIME maxon::ConvertUniversalDateTimeToSystemTime ( const UniversalDateTime &  dateTime)

◆ ConvertUniversalDateTimeToFileTime()

FILETIME maxon::ConvertUniversalDateTimeToFileTime ( const UniversalDateTime &  dateTime)

◆ GetDestructorPointer< corenodes::FrameData >()

DestructorPointer maxon::GetDestructorPointer< corenodes::FrameData > ( )

◆ MAXON_REGISTRY() [36/60]

maxon::MAXON_REGISTRY ( Class< ConvexDecompositionRef >  ,
ConvexDecompositionClasses  ,
"net.maxon.registry.convexdecompositionclasses"   
)

◆ MAXON_ENUM_LIST() [38/95]

enum maxon::GEOMETRY_TEST_EXACT maxon::MAXON_ENUM_LIST ( GEOMETRY_TEST_EXACT  )

◆ MAXON_ENUM_LIST() [39/95]

enum maxon::LOOP_OVERLAP_STATE maxon::MAXON_ENUM_LIST ( LOOP_OVERLAP_STATE  )

◆ MAXON_ENUM_LIST() [40/95]

enum maxon::GRAPH_TYPE maxon::MAXON_ENUM_LIST ( GRAPH_TYPE  )

◆ MAXON_REGISTRY() [37/60]

maxon::MAXON_REGISTRY ( InterpolateType  ,
InterpolateTypes  ,
"net.maxon.geometry.registry.interpolation.types"   
)

Registration of registry for different types of MeshMapClass.

◆ MAXON_DATATYPE() [30/66]

maxon::MAXON_DATATYPE ( SimplePolygon  ,
"net.maxon.geom.simplepolygon"   
)

◆ MAXON_DATATYPE() [31/66]

maxon::MAXON_DATATYPE ( UVWPolygon  ,
"net.maxon.geom.uvwpolygon"   
)

◆ GetPredecessor()

INDEXTYPE maxon::GetPredecessor ( INDEXTYPE  index,
COUNT  vertexCount 
)

< 2d Tangent basic data type

Calculates the predecessor index of a closed vertices loop.

Parameters
[in]indexA vertex index in the loop. Must be in the range [0..vertexCount-1].
[in]vertexCountThe number of vertices in a closed loop.
Returns
The decremented index value. If the lower limit is hit vertexCount - 1 is returned.

◆ GetSuccessor()

INDEXTYPE maxon::GetSuccessor ( INDEXTYPE  index,
COUNT  vertexCount 
)

Calculates the successor index of a closed vertices loop.

Parameters
[in]indexA vertex index in the loop. Must be in the range [0..vertexCount-1].
[in]vertexCountThe number of vertices in a closed loop.
Returns
The incremented index value. If the lower limit is hit vertexCount - 1 is returned.

◆ MAXON_ENUM_ORDERED_FLAGS() [2/2]

enum maxon::WIRE_MODE UChar maxon::MAXON_ENUM_ORDERED_FLAGS ( WIRE_MODE  )

◆ MAXON_DATATYPE() [32/66]

maxon::MAXON_DATATYPE ( Wires  ,
"net.maxon.graph.wires"   
)

◆ MAXON_ENUM_ORDERED_LIST() [2/2]

enum maxon::CONNECTION_POSITION maxon::MAXON_ENUM_ORDERED_LIST ( CONNECTION_POSITION  )

◆ Reverse() [4/5]

CONNECTION_POSITION maxon::Reverse ( CONNECTION_POSITION  pos)

Reverses the given connection position. CONNECTION_POSITION::SOURCE becomes CONNECTION_POSITION::TARGET and vice versa, CONNECTION_POSITION::CENTER remains the same.

Parameters
[in]posA connection position.
Returns
The reverse connection position.

◆ MAXON_DATATYPE() [33/66]

maxon::MAXON_DATATYPE ( GraphTransaction  ,
"net.maxon.graph.graphtransaction"   
)

◆ MAXON_DATATYPE() [34/66]

maxon::MAXON_DATATYPE ( GraphNode  ,
"net.maxon.graph.graphnode"   
)

◆ GetConnectionDirection()

PORT_DIR maxon::GetConnectionDirection ( const GraphNode &  port)

Returns the direction for connections of the given port in the context of the graph model. For an input port this function usually returns PORT_DIR::INPORT, however if the input port is at the root level of the graph model (as defined by GraphModelInterface::GetRootPath(), this is not necessarily the absolute top level because the graph model may be a nested one) then the returned direction is PORT_DIR::OUTPUT because connections will start at the port. Same for output ports.

Parameters
[in]portA port.
Returns
The direction of connections of the port in the context of its graph model.

◆ MAXON_ATTRIBUTE() [4/12]

maxon::MAXON_ATTRIBUTE ( DataDictionary  ,
GraphNodeSelection  ,
"net.maxon.mvp.graphnodeselection"   
)

◆ MAXON_ATTRIBUTE() [5/12]

maxon::MAXON_ATTRIBUTE ( DataDictionary  ,
GraphPortSelection  ,
"net.maxon.mvp.graphportselection"   
)

◆ MAXON_ATTRIBUTE() [6/12]

maxon::MAXON_ATTRIBUTE ( DataDictionary  ,
GraphWireSelection  ,
"net.maxon.mvp.graphwireselection"   
)

◆ SetGraphSelection()

static Result<void> maxon::SetGraphSelection ( const GraphNode &  root,
const SEL &  selection,
SELECTION_MODE  mode,
const DataDictionary &  userData 
)
static

◆ MAXON_ATTRIBUTE() [7/12]

maxon::MAXON_ATTRIBUTE ( Int  ,
OrderIndex  ,
"orderindex"   
)

The OrderIndex attribute is used to define the order of ports within the same parent. The values needn't be contiguous, just their relative order matters.

For a NodeSystem-based graph this is a derived attribute which can't be set directly, you have to set NODE::ATTRIBUTE::ORDERINDEX instead. This will be used to derive the value for OrderIndex.

◆ MAXON_ATTRIBUTE() [8/12]

maxon::MAXON_ATTRIBUTE ( Int  ,
InsertIndex  ,
"insertindex"   
)

The InsertIndex attribute tells about the temporal order in which sibling ports have been added to the graph. This is not to be confused with OrderIndex which defines the actual order to use.

For a NodeSystem-based graph this is a derived attribute which can't be set directly, you have to set NODE::ATTRIBUTE::INSERTINDEX instead. This will be used to derive the value for InsertIndex.

◆ MAXON_ATTRIBUTE() [9/12]

maxon::MAXON_ATTRIBUTE ( Data  ,
DefaultValue  ,
"default"   
)

The DefaultValue attribute is a derived attribute to query the default value of a port. The attribute value has to be derived by the graph implementation, typically this takes into account the value of the attribute DESCRIPTION::DATA::BASE::DEFAULTVALUE and, if that value isn't set, the default values of connected ports.

◆ MAXON_ATTRIBUTE() [10/12]

maxon::MAXON_ATTRIBUTE ( Data  ,
ConstantValue  ,
"constant"   
)

The ConstantValue attribute is a derived attribute to query the constant value of a port. The attribute value has to be derived by the graph implementation, typically this takes into account the DefaultValue, port connections and also functional nodes which can be evaluated during validation of the graph when their inputs are known constants too.

If no constant value can be derived for the port, the value is an empty Data.

◆ MAXON_ATTRIBUTE() [11/12]

maxon::MAXON_ATTRIBUTE ( String  ,
EffectiveName  ,
"effectivename"   
)

The EffectiveName attribute is a derived attribute which contains the user-visible name of a node or port.

◆ MAXON_ENUM_FLAGS() [21/33]

enum maxon::NODE_KIND maxon::MAXON_ENUM_FLAGS ( NODE_KIND  )

◆ GetPortDirection()

PORT_DIR maxon::GetPortDirection ( NODE_KIND  kind)

Returns the direction of a NODE_KIND. The given kind has to stand for ports or port lists, and the returned value is PORT_DIR::INPUT for input ports and input ports lists, or PORT_DIR::OUTPUT for output ports and output port lists.

Parameters
[in]kindThe kind of a port or port list.
Returns
The corresponding direction.

◆ operator==() [5/8]

Bool maxon::operator== ( const PathBlock &  a,
const NodePathInterface *  b 
)

◆ operator!=() [4/7]

Bool maxon::operator!= ( const PathBlock &  a,
const NodePathInterface *  b 
)

◆ operator==() [6/8]

Bool maxon::operator== ( const NodePathInterface *  b,
const PathBlock &  a 
)

◆ operator!=() [5/7]

Bool maxon::operator!= ( const NodePathInterface *  b,
const PathBlock &  a 
)

◆ operator>=()

Bool maxon::operator>= ( const PathBlock &  a,
const NodePathInterface *  b 
)

◆ operator<()

Bool maxon::operator< ( const PathBlock &  a,
const NodePathInterface *  b 
)

◆ operator>()

Bool maxon::operator> ( const PathBlock &  a,
const NodePathInterface *  b 
)

◆ operator<=()

Bool maxon::operator<= ( const PathBlock &  a,
const NodePathInterface *  b 
)

◆ operator+() [2/2]

Result<NodePath> maxon::operator+ ( const PathBlock &  a,
const NodePath &  b 
)

◆ MAXON_DECLARATION() [49/84]

maxon::MAXON_DECLARATION ( Class< AudioObjectRef >  ,
AudioObjectClass  ,
"net.maxon.image.class.audioobject"   
)

◆ MAXON_DATATYPE() [35/66]

maxon::MAXON_DATATYPE ( DrawDimensionInt  ,
"net.maxon.image.drawdimensionint"   
)

◆ MAXON_DATATYPE() [36/66]

maxon::MAXON_DATATYPE ( DrawDimensionFloat  ,
"net.maxon.image.drawdimensionfloat"   
)

◆ MAXON_DATATYPE() [37/66]

maxon::MAXON_DATATYPE ( DrawRectInt  ,
"net.maxon.image.drawrectint"   
)

◆ MAXON_DATATYPE() [38/66]

maxon::MAXON_DATATYPE ( DrawRectFloat  ,
"net.maxon.image.drawrectfloat"   
)

◆ MAXON_DATATYPE() [39/66]

maxon::MAXON_DATATYPE ( DrawPoint3dInt  ,
"net.maxon.image.drawpoint3dint"   
)

◆ MAXON_DATATYPE() [40/66]

maxon::MAXON_DATATYPE ( DrawPoint3dFloat  ,
"net.maxon.image.drawpoint3dfloat"   
)

◆ MAXON_DATATYPE() [41/66]

maxon::MAXON_DATATYPE ( DrawDimension3dInt  ,
"net.maxon.image.drawdimension3dint"   
)

◆ MAXON_DATATYPE() [42/66]

maxon::MAXON_DATATYPE ( DrawDimension3dFloat  ,
"net.maxon.image.drawdimension3dfloat"   
)

◆ MAXON_DATATYPE() [43/66]

maxon::MAXON_DATATYPE ( DrawVolumeInt  ,
"net.maxon.image.drawvolumeint"   
)

◆ MAXON_DATATYPE() [44/66]

maxon::MAXON_DATATYPE ( DrawVolumeFloat  ,
"net.maxon.image.drawvolumefloat"   
)

◆ MAXON_DATATYPE() [45/66]

maxon::MAXON_DATATYPE ( BITS  ,
"net.maxon.image.bits"   
)

◆ MAXON_ENUM_LIST() [41/95]

enum maxon::COLORPROFILEINFO maxon::MAXON_ENUM_LIST ( COLORPROFILEINFO  )

◆ MAXON_ENUM_LIST() [42/95]

enum maxon::COLORCONVERSIONINTENT maxon::MAXON_ENUM_LIST ( COLORCONVERSIONINTENT  )

◆ MAXON_ENUM_FLAGS() [22/33]

enum maxon::COLORCONVERSIONFLAGS maxon::MAXON_ENUM_FLAGS ( COLORCONVERSIONFLAGS  )

◆ SRGBtoLinear()

T maxon::SRGBtoLinear ( const T &  v)

◆ LinearToSRGB()

T maxon::LinearToSRGB ( const T &  v)

◆ MAXON_REGISTRY() [38/60]

maxon::MAXON_REGISTRY ( ColorProfile  ,
ColorProfiles  ,
"net.maxon.image.registry.colorprofiles"   
)

◆ MAXON_REGISTRY() [39/60]

maxon::MAXON_REGISTRY ( ColorSpace  ,
ColorSpaces  ,
"net.maxon.image.registry.colorspaces"   
)

Registry for color spaces.

◆ MAXON_REGISTRY() [40/60]

maxon::MAXON_REGISTRY ( ImageChannelType  ,
ImageChannelTypes  ,
"net.maxon.image.registry.imagechanneltypes"   
)

◆ ConvertPixel() [1/67]

MAXON_ATTRIBUTE_FORCE_INLINE void maxon::ConvertPixel ( Pix8u &  dst,
const Pix8u  src 
)

Converts a single component from one pixel depth to another. Supported Pixel types are: Pix8u, Pix16u, Pix32f. Proper rounding will be performed.

◆ ConvertPixel() [2/67]

MAXON_ATTRIBUTE_FORCE_INLINE void maxon::ConvertPixel ( Pix8u &  dst,
const Pix8s  src 
)

◆ ConvertPixel() [3/67]

MAXON_ATTRIBUTE_FORCE_INLINE void maxon::ConvertPixel ( Pix8u &  dst,
const Pix16u  src 
)

◆ ConvertPixel() [4/67]

MAXON_ATTRIBUTE_FORCE_INLINE void maxon::ConvertPixel ( Pix8u &  dst,
const Pix16s  src 
)

◆ ConvertPixel() [5/67]

MAXON_ATTRIBUTE_FORCE_INLINE void maxon::ConvertPixel ( Pix8u &  dst,
const Pix32u  src 
)

◆ ConvertPixel() [6/67]

MAXON_ATTRIBUTE_FORCE_INLINE void maxon::ConvertPixel ( Pix8u &  dst,
const Pix32s  src 
)

◆ ConvertPixel() [7/67]

MAXON_ATTRIBUTE_FORCE_INLINE void maxon::ConvertPixel ( Pix8u &  dst,
const Pix32f  src 
)

◆ ConvertPixel() [8/67]

MAXON_ATTRIBUTE_FORCE_INLINE void maxon::ConvertPixel ( Pix8u &  dst,
const Pix64f  src 
)

◆ ConvertPixel() [9/67]

MAXON_ATTRIBUTE_FORCE_INLINE void maxon::ConvertPixel ( Pix16u &  dst,
const Pix8u  src 
)

◆ ConvertPixel() [10/67]

MAXON_ATTRIBUTE_FORCE_INLINE void maxon::ConvertPixel ( Pix16u &  dst,
const Pix8s  src 
)

◆ ConvertPixel() [11/67]

MAXON_ATTRIBUTE_FORCE_INLINE void maxon::ConvertPixel ( Pix16u &  dst,
const Pix16u  src 
)

◆ ConvertPixel() [12/67]

MAXON_ATTRIBUTE_FORCE_INLINE void maxon::ConvertPixel ( Pix16u &  dst,
const Pix16s  src 
)

◆ ConvertPixel() [13/67]

MAXON_ATTRIBUTE_FORCE_INLINE void maxon::ConvertPixel ( Pix16u &  dst,
const Pix32u  src 
)

◆ ConvertPixel() [14/67]

MAXON_ATTRIBUTE_FORCE_INLINE void maxon::ConvertPixel ( Pix16u &  dst,
const Pix32s  src 
)

◆ ConvertPixel() [15/67]

MAXON_ATTRIBUTE_FORCE_INLINE void maxon::ConvertPixel ( Pix16u &  dst,
const Pix32f  src 
)

◆ ConvertPixel() [16/67]

MAXON_ATTRIBUTE_FORCE_INLINE void maxon::ConvertPixel ( Pix16u &  dst,
const Pix64f  src 
)

◆ ConvertPixel() [17/67]

MAXON_ATTRIBUTE_FORCE_INLINE void maxon::ConvertPixel ( Pix32u &  dst,
const Pix8u  src 
)

◆ ConvertPixel() [18/67]

MAXON_ATTRIBUTE_FORCE_INLINE void maxon::ConvertPixel ( Pix32u &  dst,
const Pix8s  src 
)

◆ ConvertPixel() [19/67]

MAXON_ATTRIBUTE_FORCE_INLINE void maxon::ConvertPixel ( Pix32u &  dst,
const Pix16u  src 
)

◆ ConvertPixel() [20/67]

MAXON_ATTRIBUTE_FORCE_INLINE void maxon::ConvertPixel ( Pix32u &  dst,
const Pix16s  src 
)

◆ ConvertPixel() [21/67]

MAXON_ATTRIBUTE_FORCE_INLINE void maxon::ConvertPixel ( Pix32u &  dst,
const Pix32u  src 
)

◆ ConvertPixel() [22/67]

MAXON_ATTRIBUTE_FORCE_INLINE void maxon::ConvertPixel ( Pix32u &  dst,
const Pix32s  src 
)

◆ ConvertPixel() [23/67]

MAXON_ATTRIBUTE_FORCE_INLINE void maxon::ConvertPixel ( Pix32u &  dst,
const Pix32f  src 
)

◆ ConvertPixel() [24/67]

MAXON_ATTRIBUTE_FORCE_INLINE void maxon::ConvertPixel ( Pix32u &  dst,
const Pix64f  src 
)

◆ ConvertPixel() [25/67]

MAXON_ATTRIBUTE_FORCE_INLINE void maxon::ConvertPixel ( Pix8s &  dst,
const Pix8u  src 
)

to signed

◆ ConvertPixel() [26/67]

MAXON_ATTRIBUTE_FORCE_INLINE void maxon::ConvertPixel ( Pix8s &  dst,
const Pix8s  src 
)

◆ ConvertPixel() [27/67]

MAXON_ATTRIBUTE_FORCE_INLINE void maxon::ConvertPixel ( Pix8s &  dst,
const Pix16u  src 
)

◆ ConvertPixel() [28/67]

MAXON_ATTRIBUTE_FORCE_INLINE void maxon::ConvertPixel ( Pix8s &  dst,
const Pix16s  src 
)

◆ ConvertPixel() [29/67]

MAXON_ATTRIBUTE_FORCE_INLINE void maxon::ConvertPixel ( Pix8s &  dst,
const Pix32u  src 
)

◆ ConvertPixel() [30/67]

MAXON_ATTRIBUTE_FORCE_INLINE void maxon::ConvertPixel ( Pix8s &  dst,
const Pix32s  src 
)

◆ ConvertPixel() [31/67]

MAXON_ATTRIBUTE_FORCE_INLINE void maxon::ConvertPixel ( Pix8s &  dst,
const Pix32f  src 
)

◆ ConvertPixel() [32/67]

MAXON_ATTRIBUTE_FORCE_INLINE void maxon::ConvertPixel ( Pix8s &  dst,
const Pix64f  src 
)

◆ ConvertPixel() [33/67]

MAXON_ATTRIBUTE_FORCE_INLINE void maxon::ConvertPixel ( Pix16s &  dst,
const Pix8u  src 
)

◆ ConvertPixel() [34/67]

MAXON_ATTRIBUTE_FORCE_INLINE void maxon::ConvertPixel ( Pix16s &  dst,
const Pix8s  src 
)

◆ ConvertPixel() [35/67]

MAXON_ATTRIBUTE_FORCE_INLINE void maxon::ConvertPixel ( Pix16s &  dst,
const Pix16u  src 
)

◆ ConvertPixel() [36/67]

MAXON_ATTRIBUTE_FORCE_INLINE void maxon::ConvertPixel ( Pix16s &  dst,
const Pix16s  src 
)

◆ ConvertPixel() [37/67]

MAXON_ATTRIBUTE_FORCE_INLINE void maxon::ConvertPixel ( Pix16s &  dst,
const Pix32u  src 
)

◆ ConvertPixel() [38/67]

MAXON_ATTRIBUTE_FORCE_INLINE void maxon::ConvertPixel ( Pix16s &  dst,
const Pix32s  src 
)

◆ ConvertPixel() [39/67]

MAXON_ATTRIBUTE_FORCE_INLINE void maxon::ConvertPixel ( Pix16s &  dst,
const Pix32f  src 
)

◆ ConvertPixel() [40/67]

MAXON_ATTRIBUTE_FORCE_INLINE void maxon::ConvertPixel ( Pix16s &  dst,
const Pix64f  src 
)

◆ ConvertPixel() [41/67]

MAXON_ATTRIBUTE_FORCE_INLINE void maxon::ConvertPixel ( Pix32s &  dst,
const Pix8u  src 
)

◆ ConvertPixel() [42/67]

MAXON_ATTRIBUTE_FORCE_INLINE void maxon::ConvertPixel ( Pix32s &  dst,
const Pix8s  src 
)

◆ ConvertPixel() [43/67]

MAXON_ATTRIBUTE_FORCE_INLINE void maxon::ConvertPixel ( Pix32s &  dst,
const Pix16u  src 
)

◆ ConvertPixel() [44/67]

MAXON_ATTRIBUTE_FORCE_INLINE void maxon::ConvertPixel ( Pix32s &  dst,
const Pix16s  src 
)

◆ ConvertPixel() [45/67]

MAXON_ATTRIBUTE_FORCE_INLINE void maxon::ConvertPixel ( Pix32s &  dst,
const Pix32u  src 
)

◆ ConvertPixel() [46/67]

MAXON_ATTRIBUTE_FORCE_INLINE void maxon::ConvertPixel ( Pix32s &  dst,
const Pix32s  src 
)

◆ ConvertPixel() [47/67]

MAXON_ATTRIBUTE_FORCE_INLINE void maxon::ConvertPixel ( Pix32s &  dst,
const Pix32f  src 
)

◆ ConvertPixel() [48/67]

MAXON_ATTRIBUTE_FORCE_INLINE void maxon::ConvertPixel ( Pix32s &  dst,
const Pix64f  src 
)

◆ ConvertPixel() [49/67]

MAXON_ATTRIBUTE_FORCE_INLINE void maxon::ConvertPixel ( Float32 &  dst,
const Pix8u  src 
)

◆ ConvertPixel() [50/67]

MAXON_ATTRIBUTE_FORCE_INLINE void maxon::ConvertPixel ( Float64 &  dst,
const Pix8u  src 
)

◆ ConvertPixel() [51/67]

MAXON_ATTRIBUTE_FORCE_INLINE void maxon::ConvertPixel ( Pix32f &  dst,
const Pix16u  src 
)

◆ ConvertPixel() [52/67]

MAXON_ATTRIBUTE_FORCE_INLINE void maxon::ConvertPixel ( Pix32f &  dst,
const Pix32u  src 
)

◆ ConvertPixel() [53/67]

MAXON_ATTRIBUTE_FORCE_INLINE void maxon::ConvertPixel ( Pix32f &  dst,
const Pix32s  src 
)

◆ ConvertPixel() [54/67]

MAXON_ATTRIBUTE_FORCE_INLINE void maxon::ConvertPixel ( Pix32f &  dst,
const Pix32f  src 
)

◆ ConvertPixel() [55/67]

MAXON_ATTRIBUTE_FORCE_INLINE void maxon::ConvertPixel ( Pix32f &  dst,
const Pix64f  src 
)

◆ ConvertPixel() [56/67]

MAXON_ATTRIBUTE_FORCE_INLINE void maxon::ConvertPixel ( Pix64f &  dst,
const Pix16u  src 
)

◆ ConvertPixel() [57/67]

MAXON_ATTRIBUTE_FORCE_INLINE void maxon::ConvertPixel ( Pix64f &  dst,
const Pix32u  src 
)

◆ ConvertPixel() [58/67]

MAXON_ATTRIBUTE_FORCE_INLINE void maxon::ConvertPixel ( Pix64f &  dst,
const Pix32s  src 
)

◆ ConvertPixel() [59/67]

MAXON_ATTRIBUTE_FORCE_INLINE void maxon::ConvertPixel ( Pix64f &  dst,
const Pix32f  src 
)

◆ ConvertPixel() [60/67]

MAXON_ATTRIBUTE_FORCE_INLINE void maxon::ConvertPixel ( Pix64f &  dst,
const Pix64f  src 
)

◆ ConvertPixel() [61/67]

MAXON_ATTRIBUTE_FORCE_INLINE void maxon::ConvertPixel ( Pix16f &  dst,
const Pix8u  src 
)

◆ ConvertPixel() [62/67]

MAXON_ATTRIBUTE_FORCE_INLINE void maxon::ConvertPixel ( Pix16f &  dst,
const Pix16u  src 
)

◆ ConvertPixel() [63/67]

MAXON_ATTRIBUTE_FORCE_INLINE void maxon::ConvertPixel ( Pix16f &  dst,
const Pix32u  src 
)

◆ ConvertPixel() [64/67]

MAXON_ATTRIBUTE_FORCE_INLINE void maxon::ConvertPixel ( Pix16f &  dst,
const Pix32s  src 
)

◆ ConvertPixel() [65/67]

MAXON_ATTRIBUTE_FORCE_INLINE void maxon::ConvertPixel ( Pix16f &  dst,
const Pix16f  src 
)

◆ ConvertPixel() [66/67]

MAXON_ATTRIBUTE_FORCE_INLINE void maxon::ConvertPixel ( Pix16f &  dst,
const Pix32f  src 
)

◆ ConvertPixel() [67/67]

MAXON_ATTRIBUTE_FORCE_INLINE void maxon::ConvertPixel ( Pix16f &  dst,
const Pix64f  src 
)

◆ IsPixelIdentical()

MAXON_ATTRIBUTE_FORCE_INLINE Bool maxon::IsPixelIdentical ( PIXELDEPTH  a,
PIXELDEPTH  b,
Int  oneTolerance 
)

Compares 2 Pixel values with a given tolerance.

Parameters
[in]aPixel Value 1.
[in]bPixel Value 2.
[in]oneToleranceTolerance of the pixel in the [0..255] range. If the PIXELDEPTH is different to Pix8u it will be converted by using the contant defined in PixelDepthInfo<PIXELDEPTH>::PIXELTOLERANCE_ONE.
Returns
True if the difference is below the given tolerance.

◆ MAXON_REGISTRY() [41/60]

maxon::MAXON_REGISTRY ( Class< ImagePixelStorage >  ,
ImagePixelStorageClasses  ,
"net.maxon.image.registry.imagepixelstorageclasses"   
)

◆ MAXON_DATATYPE() [46/66]

maxon::MAXON_DATATYPE ( UpdateRegion  ,
"net.maxon.image.updateregion"   
)

◆ MAXON_DECLARATION() [50/84]

maxon::MAXON_DECLARATION ( Class< ImageRegionTilesObserverRef >  ,
ImageRegionSingleTileObserverClass  ,
"net.maxon.class.imageregionobserver.tiles"   
)

Performs a per-tile AABB tracking of changes. The class is thread-safe for conditions where production and consumption of region changes are performed on different threads.

◆ MAXON_ENUM_LIST() [43/95]

enum maxon::LAYERSETMODE maxon::MAXON_ENUM_LIST ( LAYERSETMODE  )

◆ MAXON_DECLARATION() [51/84]

maxon::MAXON_DECLARATION ( Class< MediaStreamAudioDataExportRef >  ,
MediaStreamAudioDataExportClass  ,
"net.maxon.image.class.mediastreamaudiodataexport"   
)

◆ MediaTraverseChildren()

static Result<Bool> maxon::MediaTraverseChildren ( const REFTYPE &  t,
const ConstDataPtr &  branch,
const Delegate< Result< Bool >(const REFTYPE &child, const REFTYPE &parent, const ConstDataPtr &branch, Int depth)> &  func,
Int  depth = 0 
)
static

Helper function to traverse all children of the root object t.

MediaStreamRef stream; // object with hierarchy to run through
BaseArray<MediaStreamRef> res;
MediaTraverseChildren<MediaStreamRef>(stream, ConstDataPtr(),
[&res](const MediaStreamRef& child, const MediaStreamRef& parent, const ConstDataPtr& branch, Int depth) -> Result<Bool>
{
iferr_scope;
res.Append(child) iferr_return;
return true;
}, 0) iferr_return;
Parameters
[in]tobject to iterate.
[in]funcfunction which is called for each object.
Returns
returns false if iteration should stop. otherwise true to continue.

◆ MediaTraverseMeAndChildren()

static Result<Bool> maxon::MediaTraverseMeAndChildren ( const REFTYPE &  t,
const REFTYPE &  parent,
const ConstDataPtr &  branch,
const Delegate< Result< Bool >(const REFTYPE &child, const REFTYPE &parent, const ConstDataPtr &branch, Int depth)> &  func,
Int  depth = 0 
)
static

Helper function to traverse all children of the root object t, but also the given object.

MediaStreamRef stream; // object with hierarchy to run through
BaseArray<MediaStreamRef> res;
MediaTraverseMeAndChildren<MediaStreamRef>(stream, MediaStreamRef(), ConstDataPtr(),
[&res](const MediaStreamRef& child, const MediaStreamRef& parent, const ConstDataPtr& branch, Int depth) -> Result<Bool>
{
iferr_scope;
res.Append(child) iferr_return;
return true;
}) iferr_return;
Parameters
[in]tobject to iterate.
[in]funcfunction which is called for each object.
Returns
returns false if iteration should stop. otherwise true to continue.

◆ MAXON_ENUM_LIST() [44/95]

enum maxon::MEDIAFORMATTYPE maxon::MAXON_ENUM_LIST ( MEDIAFORMATTYPE  )

◆ MAXON_ENUM_LIST() [45/95]

enum maxon::MEDIAALPHATYPE maxon::MAXON_ENUM_LIST ( MEDIAALPHATYPE  )

◆ MAXON_DECLARATION() [52/84]

maxon::MAXON_DECLARATION ( Class< MediaBaseRef >  ,
MediaBaseClass  ,
"net.maxon.image.class.mediabase"   
)

◆ MAXON_DECLARATION() [53/84]

maxon::MAXON_DECLARATION ( Class< MediaConverterRef >  ,
MediaConverterBaseClass  ,
"net.maxon.image.class.mediaconverterbase"   
)

◆ MAXON_DECLARATION() [54/84]

maxon::MAXON_DECLARATION ( Class< FileFormat >  ,
FileFormatImageBaseClass  ,
"net.maxon.image.class.fileformatimagebase"   
)

This class should be added to your own image fileformat implementation. It implements default values for GetData() for FILEFORMATPROPERTIES of images.

◆ MAXON_REGISTRY() [42/60]

maxon::MAXON_REGISTRY ( Class< MediaOutputUrlRef >  ,
ImageSaverClasses  ,
"net.maxon.image.registry.imagesaverclasses"   
)

Registry to register all image saver.

◆ MAXON_ENUM_LIST() [46/95]

enum maxon::RLACHANNELS maxon::MAXON_ENUM_LIST ( RLACHANNELS  )

◆ MAXON_ENUM_FLAGS() [23/33]

enum maxon::RLAFLAGS maxon::MAXON_ENUM_FLAGS ( RLAFLAGS  )

◆ GetRlaRpfChannelSymbol()

Char maxon::GetRlaRpfChannelSymbol ( RLACHANNELS  channel)

◆ GetRlaRpfChannelSize()

Int maxon::GetRlaRpfChannelSize ( RLACHANNELS  channel)

◆ GetRlaRpfChannelType()

Tuple<ImageChannel, ImageChannel, ImageChannel> maxon::GetRlaRpfChannelType ( RLACHANNELS  channel)

◆ ToWindowsTime()

Int64 maxon::ToWindowsTime ( const TimeValue &  time)

◆ ToMaxonTime()

TimeValue maxon::ToMaxonTime ( Int64  time)

◆ FpsToInt()

Vec2<Int> maxon::FpsToInt ( Float  fps)

◆ MAXON_ENUM_FLAGS() [24/33]

enum maxon::SELECTIONHANDLERRESULT maxon::MAXON_ENUM_FLAGS ( SELECTIONHANDLERRESULT  )

◆ MAXON_DECLARATION() [55/84]

maxon::MAXON_DECLARATION ( Class< MediaOutputRef >  ,
MediaOutputBaseClass  ,
"net.maxon.image.class.mediaoutputbase"   
)

◆ MAXON_DECLARATION() [56/84]

maxon::MAXON_DECLARATION ( Class< MediaOutputTextureRef >  ,
MediaOutputTextureClass  ,
"net.maxon.image.class.mediaoutputtexture"   
)

◆ MAXON_DECLARATION() [57/84]

maxon::MAXON_DECLARATION ( Class< MediaOutputUrlRef >  ,
MediaOutputUrlBaseClass  ,
"net.maxon.image.class.mediaoutputurlbase"   
)

◆ MediaSessionImport()

Result<MediaSessionRef> maxon::MediaSessionImport ( const Url &  fileName,
const TimeValue &  targetTime,
MEDIASESSIONFLAGS  flags,
const MediaOutputRef &  outputConverter,
const MediaOutputSelectionHandler &  selectionHandler,
const MediaSessionProgressCallback &  progressCallback,
const FileFormatHandler &  preferredHandler,
const ValueReceiver< const FileFormatHandler & > &  fileFormats = {} 
)

Helper function to load a image or movie into any MediaOutputRef. this allows to load images/movies directly to the place it belongs to (e.g. directly to any opengl buffer).

Parameters
[in]fileNameUrl to load.
[in]targetTimeFrame to load from a stream. TimeValue() will load the first frame.
[in]flagsSee MEDIASESSIONFLAGS for details.
[in]outputConverterMediaOutputRef which is setup to load the data in.
[in]selectionHandlerOptional handler which is called to filter which elements should be loaded.
[in]progressCallbackOptional callback to receive the progress of the loader.
[in]preferredHandlerThis is a optional parameter which allows to give a preferred handler (which could be already detected before).
Returns
A valid MediaSessionRef on success. This session can optionally be used to load subsequent images into the same buffers by calling session.Convert(time) again.

◆ MAXON_ENUM_FLAGS() [25/33]

enum maxon::MEDIASESSIONFLAGS maxon::MAXON_ENUM_FLAGS ( MEDIASESSIONFLAGS  )

◆ MAXON_DECLARATION() [58/84]

maxon::MAXON_DECLARATION ( Class< MediaSessionRef >  ,
MediaSessionObject  ,
"net.maxon.image.class.mediasessionobject"   
)

◆ MAXON_DECLARATION() [59/84]

maxon::MAXON_DECLARATION ( Class< MediaStreamRef >  ,
MediaStreamBaseClass  ,
"net.maxon.image.class.mediastreambase"   
)

◆ MAXON_DECLARATION() [60/84]

maxon::MAXON_DECLARATION ( Class< MediaStreamExifDataRef >  ,
MediaStreamExifDataClass  ,
"net.maxon.image.class.mediastreamexifdata"   
)

◆ MAXON_DECLARATION() [61/84]

maxon::MAXON_DECLARATION ( Class< MediaStreamImageBaseRef >  ,
MediaStreamImageBaseClass  ,
"net.maxon.image.class.mediastreamimagebase"   
)

◆ MAXON_DECLARATION() [62/84]

maxon::MAXON_DECLARATION ( Class< MediaStreamImageDataImportRef >  ,
MediaStreamImageDataImportClass  ,
"net.maxon.image.class.mediastreamimagedataimport"   
)

◆ MAXON_DECLARATION() [63/84]

maxon::MAXON_DECLARATION ( Class< MediaStreamImageDataExportRef >  ,
MediaStreamImageDataExportClass  ,
"net.maxon.image.class.mediastreamimagedataexport"   
)

◆ MAXON_DECLARATION() [64/84]

maxon::MAXON_DECLARATION ( Class< MediaStreamAudioDataImportRef >  ,
MediaStreamAudioDataImportClass  ,
"net.maxon.image.class.mediastreamaudiodataimport"   
)

◆ MAXON_DECLARATION() [65/84]

maxon::MAXON_DECLARATION ( Class< MediaStreamImageDataForwardImportRef >  ,
MediaStreamForwardImageDataStreamsImportClass  ,
"net.maxon.image.class.mediastreamforwardimagedatastreamsimport"   
)

◆ GetSelectedFormatPreferAspectRatio_1_1()

Result<Data> maxon::GetSelectedFormatPreferAspectRatio_1_1 ( const MediaStreamRef &  stream,
MediaStreamFormat &  resFormat 
)

GetSelectedFormatPreferAspectRatio_1_1 tries to find a format with a 1:1 aspect ratio.

Parameters
[in]streamStream to determine.
[in]resFormatReturns the MediaStreamFormat of the preferred format.
Returns
Returns the preferred format.

◆ MAXON_DECLARATION() [66/84]

maxon::MAXON_DECLARATION ( Class< MediaStreamFormat >  ,
MediaStreamFormatClass  ,
"net.maxon.image.class.mediastreamformat"   
)

◆ MAXON_DECLARATION() [67/84]

maxon::MAXON_DECLARATION ( Class< MediaStreamProperties >  ,
MediaStreamPropertiesClass  ,
"net.maxon.image.class.mediastreamproperties"   
)

◆ BlendOver()

MAXON_ATTRIBUTE_FORCE_INLINE FLOATTYPE maxon::BlendOver ( FLOATTYPE  background,
FLOATTYPE  foreground 
)

Implementations of commonly used blend modes which can be applied per-component.

Blend Modes Blend results are not necessarily meant to match the result in Photoshop (or any other application). Photoshop in particular has some rather "creative" alpha handling which is not attempted to be reproduced here. Moreover, Photoshop doesn't support half of their blend modes in 32-bit mode, so it's impossible to compare results in any meaningful way.

These implementations are mostly based on those from Bodypaint as well as the Fusion shader. Over (Normal)

◆ BlendAverage()

MAXON_ATTRIBUTE_FORCE_INLINE FLOATTYPE maxon::BlendAverage ( FLOATTYPE  background,
FLOATTYPE  foreground 
)

Average.

◆ BlendMultiply()

MAXON_ATTRIBUTE_FORCE_INLINE FLOATTYPE maxon::BlendMultiply ( FLOATTYPE  background,
FLOATTYPE  foreground 
)

Multiply.

◆ BlendScreen()

MAXON_ATTRIBUTE_FORCE_INLINE FLOATTYPE maxon::BlendScreen ( FLOATTYPE  background,
FLOATTYPE  foreground 
)

Screen.

◆ BlendSubtract()

MAXON_ATTRIBUTE_FORCE_INLINE FLOATTYPE maxon::BlendSubtract ( FLOATTYPE  background,
FLOATTYPE  foreground 
)

Subtract.

◆ BlendDivide()

MAXON_ATTRIBUTE_FORCE_INLINE FLOATTYPE maxon::BlendDivide ( FLOATTYPE  background,
FLOATTYPE  foreground 
)

Divide.

◆ BlendAdd()

MAXON_ATTRIBUTE_FORCE_INLINE FLOATTYPE maxon::BlendAdd ( FLOATTYPE  background,
FLOATTYPE  foreground 
)

Add.

◆ BlendOverlay()

MAXON_ATTRIBUTE_FORCE_INLINE FLOATTYPE maxon::BlendOverlay ( FLOATTYPE  background,
FLOATTYPE  foreground 
)

Overlay.

◆ BlendHardLight()

MAXON_ATTRIBUTE_FORCE_INLINE FLOATTYPE maxon::BlendHardLight ( FLOATTYPE  background,
FLOATTYPE  foreground 
)

Hard Light.

◆ BlendSoftLight()

MAXON_ATTRIBUTE_FORCE_INLINE FLOATTYPE maxon::BlendSoftLight ( FLOATTYPE  background,
FLOATTYPE  foreground 
)

Soft Light.

◆ BlendDarken()

MAXON_ATTRIBUTE_FORCE_INLINE FLOATTYPE maxon::BlendDarken ( FLOATTYPE  background,
FLOATTYPE  foreground 
)

Darken (Min)

◆ BlendLighten()

MAXON_ATTRIBUTE_FORCE_INLINE FLOATTYPE maxon::BlendLighten ( FLOATTYPE  background,
FLOATTYPE  foreground 
)

Lighten (Max)

◆ BlendPinLight()

MAXON_ATTRIBUTE_FORCE_INLINE FLOATTYPE maxon::BlendPinLight ( FLOATTYPE  background,
FLOATTYPE  foreground 
)

Pin Light.

◆ BlendDifference()

MAXON_ATTRIBUTE_FORCE_INLINE FLOATTYPE maxon::BlendDifference ( FLOATTYPE  background,
FLOATTYPE  foreground 
)

Difference.

◆ BlendExclusion()

MAXON_ATTRIBUTE_FORCE_INLINE FLOATTYPE maxon::BlendExclusion ( FLOATTYPE  background,
FLOATTYPE  foreground 
)

Exclusion.

◆ BlendNegative()

MAXON_ATTRIBUTE_FORCE_INLINE FLOATTYPE maxon::BlendNegative ( FLOATTYPE  background,
FLOATTYPE  foreground 
)

Negative.

◆ BlendStamp()

MAXON_ATTRIBUTE_FORCE_INLINE FLOATTYPE maxon::BlendStamp ( FLOATTYPE  background,
FLOATTYPE  foreground 
)

Stamp.

◆ BlendXor()

MAXON_ATTRIBUTE_FORCE_INLINE FLOATTYPE maxon::BlendXor ( FLOATTYPE  background,
FLOATTYPE  foreground 
)

Xor.

◆ BlendGlow()

MAXON_ATTRIBUTE_FORCE_INLINE FLOATTYPE maxon::BlendGlow ( FLOATTYPE  background,
FLOATTYPE  foreground 
)

Glow.

◆ BlendReflect()

MAXON_ATTRIBUTE_FORCE_INLINE FLOATTYPE maxon::BlendReflect ( FLOATTYPE  background,
FLOATTYPE  foreground 
)

Reflect.

◆ BlendHeat()

MAXON_ATTRIBUTE_FORCE_INLINE FLOATTYPE maxon::BlendHeat ( FLOATTYPE  background,
FLOATTYPE  foreground 
)

Heat.

◆ BlendFreeze()

MAXON_ATTRIBUTE_FORCE_INLINE FLOATTYPE maxon::BlendFreeze ( FLOATTYPE  background,
FLOATTYPE  foreground 
)

Freeze.

◆ BlendHypot()

MAXON_ATTRIBUTE_FORCE_INLINE FLOATTYPE maxon::BlendHypot ( FLOATTYPE  background,
FLOATTYPE  foreground 
)

Hypot (similar effect to screen but a bit weaker)

◆ Dissolve()

MAXON_ATTRIBUTE_FORCE_INLINE FLOATTYPE maxon::Dissolve ( FLOATTYPE  background,
FLOATTYPE  foreground 
)

Dissolve.

◆ BlendHardMix()

MAXON_ATTRIBUTE_FORCE_INLINE FLOATTYPE maxon::BlendHardMix ( FLOATTYPE  background,
FLOATTYPE  foreground 
)

Hard Mix.

◆ BlendColorDodge()

MAXON_ATTRIBUTE_FORCE_INLINE FLOATTYPE maxon::BlendColorDodge ( FLOATTYPE  background,
FLOATTYPE  foreground 
)

Color Dodge.

◆ BlendColorBurn()

MAXON_ATTRIBUTE_FORCE_INLINE FLOATTYPE maxon::BlendColorBurn ( FLOATTYPE  background,
FLOATTYPE  foreground 
)

Color Burn.

◆ BlendLinearDodge()

MAXON_ATTRIBUTE_FORCE_INLINE FLOATTYPE maxon::BlendLinearDodge ( FLOATTYPE  background,
FLOATTYPE  foreground 
)

Linear Dodge.

◆ BlendLinearBurn()

MAXON_ATTRIBUTE_FORCE_INLINE FLOATTYPE maxon::BlendLinearBurn ( FLOATTYPE  background,
FLOATTYPE  foreground 
)

Linear Burn.

◆ BlendVividLight()

MAXON_ATTRIBUTE_FORCE_INLINE FLOATTYPE maxon::BlendVividLight ( FLOATTYPE  background,
FLOATTYPE  foreground 
)

Vivid Light.

◆ BlendHue()

MAXON_ATTRIBUTE_FORCE_INLINE COLORTYPE maxon::BlendHue ( const COLORTYPE &  background,
const COLORTYPE &  foreground 
)

Hue.

"Complex" blend modes These modes cannot be applied per-component. Alpha has no meaning with these blend modes, so we just return the background layer's alpha value.

◆ BlendSaturation()

MAXON_ATTRIBUTE_FORCE_INLINE COLORTYPE maxon::BlendSaturation ( const COLORTYPE &  background,
const COLORTYPE &  foreground 
)

Saturation.

◆ BlendLuminance()

MAXON_ATTRIBUTE_FORCE_INLINE COLORTYPE maxon::BlendLuminance ( const COLORTYPE &  background,
const COLORTYPE &  foreground 
)

Luminance.

◆ BlendColor()

MAXON_ATTRIBUTE_FORCE_INLINE COLORTYPE maxon::BlendColor ( const COLORTYPE &  background,
const COLORTYPE &  foreground 
)

Color.

◆ BlendLevr()

MAXON_ATTRIBUTE_FORCE_INLINE COLORTYPE maxon::BlendLevr ( const COLORTYPE &  background,
const COLORTYPE &  foreground 
)

Levr.

◆ LuminanceColor()

static MAXON_ATTRIBUTE_FORCE_INLINE COLORTYPE::ValueType maxon::LuminanceColor ( const COLORTYPE &  color)
static

◆ LuminanceColorA()

static MAXON_ATTRIBUTE_FORCE_INLINE COLORATYPE::ValueType maxon::LuminanceColorA ( const COLORATYPE &  color)
static

◆ BlendDarker()

MAXON_ATTRIBUTE_FORCE_INLINE COLORTYPE maxon::BlendDarker ( const COLORTYPE &  background,
const COLORTYPE &  foreground 
)

Darker.

◆ BlendLighter()

MAXON_ATTRIBUTE_FORCE_INLINE COLORTYPE maxon::BlendLighter ( const COLORTYPE &  background,
const COLORTYPE &  foreground 
)

Lighter.

◆ MAXON_ENUM_LIST() [47/95]

enum maxon::BLEND_MODES maxon::MAXON_ENUM_LIST ( BLEND_MODES  )

◆ BlendRGBA()

static MAXON_ATTRIBUTE_FORCE_INLINE COLORATYPE maxon::BlendRGBA ( const COLORATYPE &  background,
const COLORATYPE &  foreground,
typename COLORATYPE::ValueType  opacity 
)
static

◆ XyzToRgb()

MAXON_ATTRIBUTE_FORCE_INLINE Color maxon::XyzToRgb ( const Color &  xyz)

◆ RgbToXyz()

MAXON_ATTRIBUTE_FORCE_INLINE Color maxon::RgbToXyz ( const Color &  rgb)

◆ RgbToCmy()

MAXON_ATTRIBUTE_FORCE_INLINE Color maxon::RgbToCmy ( const Color  rgb)

◆ CmyToRgb()

MAXON_ATTRIBUTE_FORCE_INLINE Color maxon::CmyToRgb ( const Color  cmy)

◆ RgbToHsv()

MAXON_ATTRIBUTE_FORCE_INLINE COLORTYPE maxon::RgbToHsv ( const COLORTYPE &  rgb)

◆ HsvToRgb()

MAXON_ATTRIBUTE_FORCE_INLINE COLORTYPE maxon::HsvToRgb ( const COLORTYPE &  hsv)

◆ RgbToHsl()

MAXON_ATTRIBUTE_FORCE_INLINE COLORTYPE maxon::RgbToHsl ( const COLORTYPE &  rgb)

◆ Value()

MAXON_ATTRIBUTE_FORCE_INLINE FLOATTYPE maxon::Value ( FLOATTYPE  nl,
FLOATTYPE  n2,
FLOATTYPE  hue 
)

◆ HslToRgb()

MAXON_ATTRIBUTE_FORCE_INLINE COLORTYPE maxon::HslToRgb ( const COLORTYPE &  hsl)

◆ ColorTemperatureToRGB()

MAXON_ATTRIBUTE_FORCE_INLINE Color maxon::ColorTemperatureToRGB ( Float  temperature)

Returns the color of an ideal black-body radiator at the given temperature. https://en.wikipedia.org/wiki/Color_temperature

◆ Fract()

MAXON_ATTRIBUTE_FORCE_INLINE enable_if_float<T> maxon::Fract ( T  value)

◆ Invert()

MAXON_ATTRIBUTE_FORCE_INLINE enable_if_float<T> maxon::Invert ( T  value)

◆ ClampValueCustom()

MAXON_ATTRIBUTE_FORCE_INLINE enable_if_scalar<T> maxon::ClampValueCustom ( T  value,
T  lowerLimit,
T  upperLimit 
)

◆ MinCustom()

MAXON_ATTRIBUTE_FORCE_INLINE enable_if_scalar<T> maxon::MinCustom ( T  a,
T  b 
)

◆ MaxCustom()

MAXON_ATTRIBUTE_FORCE_INLINE enable_if_scalar<T> maxon::MaxCustom ( T  a,
T  b 
)

◆ SignNoTemplate()

MAXON_ATTRIBUTE_FORCE_INLINE enable_if_scalar<T> maxon::SignNoTemplate ( T  value)

◆ FMod()

MAXON_ATTRIBUTE_FORCE_INLINE enable_if_integral<T> maxon::FMod ( T  a,
T  b 
)

◆ MapRange()

MAXON_ATTRIBUTE_FORCE_INLINE enable_if_scalar<T> maxon::MapRange ( T  input,
T  inputMin,
T  inputMax,
T  outputMin,
T  outputMax 
)

◆ Step()

MAXON_ATTRIBUTE_FORCE_INLINE enable_if_float<T> maxon::Step ( T  value,
T  threshold 
)

◆ Quantize()

MAXON_ATTRIBUTE_FORCE_INLINE enable_if_float<T> maxon::Quantize ( T  value,
T  steps 
)

◆ Cbrt()

MAXON_ATTRIBUTE_FORCE_INLINE enable_if_float<T> maxon::Cbrt ( T  input)

◆ SquaredLength() [1/10]

MAXON_ATTRIBUTE_FORCE_INLINE Float32 maxon::SquaredLength ( const Vector2d32 &  input)

◆ SquaredLength() [2/10]

MAXON_ATTRIBUTE_FORCE_INLINE Float64 maxon::SquaredLength ( const Vector2d64 &  input)

◆ SquaredLength() [3/10]

MAXON_ATTRIBUTE_FORCE_INLINE Float32 maxon::SquaredLength ( const Vector32 &  input)

◆ SquaredLength() [4/10]

MAXON_ATTRIBUTE_FORCE_INLINE Float64 maxon::SquaredLength ( const Vector64 &  input)

◆ SquaredLength() [5/10]

MAXON_ATTRIBUTE_FORCE_INLINE Float32 maxon::SquaredLength ( const Vector4d32 &  input)

◆ SquaredLength() [6/10]

MAXON_ATTRIBUTE_FORCE_INLINE Float64 maxon::SquaredLength ( const Vector4d64 &  input)

◆ SquaredLength() [7/10]

MAXON_ATTRIBUTE_FORCE_INLINE Float32 maxon::SquaredLength ( const Color32 &  input)

◆ SquaredLength() [8/10]

MAXON_ATTRIBUTE_FORCE_INLINE Float64 maxon::SquaredLength ( const Color64 &  input)

◆ SquaredLength() [9/10]

MAXON_ATTRIBUTE_FORCE_INLINE Float32 maxon::SquaredLength ( const ColorA32 &  input)

◆ SquaredLength() [10/10]

MAXON_ATTRIBUTE_FORCE_INLINE Float64 maxon::SquaredLength ( const ColorA64 &  input)

◆ Length() [1/10]

MAXON_ATTRIBUTE_FORCE_INLINE Float32 maxon::Length ( const Vector2d32 &  input)

◆ Length() [2/10]

MAXON_ATTRIBUTE_FORCE_INLINE Float64 maxon::Length ( const Vector2d64 &  input)

◆ Length() [3/10]

MAXON_ATTRIBUTE_FORCE_INLINE Float32 maxon::Length ( const Vector32 &  input)

◆ Length() [4/10]

MAXON_ATTRIBUTE_FORCE_INLINE Float64 maxon::Length ( const Vector64 &  input)

◆ Length() [5/10]

MAXON_ATTRIBUTE_FORCE_INLINE Float32 maxon::Length ( const Vector4d32 &  input)

◆ Length() [6/10]

MAXON_ATTRIBUTE_FORCE_INLINE Float64 maxon::Length ( const Vector4d64 &  input)

◆ Length() [7/10]

MAXON_ATTRIBUTE_FORCE_INLINE Float32 maxon::Length ( const Color32 &  input)

◆ Length() [8/10]

MAXON_ATTRIBUTE_FORCE_INLINE Float64 maxon::Length ( const Color64 &  input)

◆ Length() [9/10]

MAXON_ATTRIBUTE_FORCE_INLINE Float32 maxon::Length ( const ColorA32 &  input)

◆ Length() [10/10]

MAXON_ATTRIBUTE_FORCE_INLINE Float64 maxon::Length ( const ColorA64 &  input)

◆ SafePow() [1/2]

MAXON_ATTRIBUTE_FORCE_INLINE Float64 maxon::SafePow ( Float64  v1,
Float64  v2 
)

◆ SafePow() [2/2]

MAXON_ATTRIBUTE_FORCE_INLINE Float32 maxon::SafePow ( Float32  v1,
Float32  v2 
)

◆ SafeSqrt() [1/2]

MAXON_ATTRIBUTE_FORCE_INLINE Float64 maxon::SafeSqrt ( Float64  v)

◆ SafeSqrt() [2/2]

MAXON_ATTRIBUTE_FORCE_INLINE Float32 maxon::SafeSqrt ( Float32  v)

◆ MATH_HELPER_INSTANTIATE() [1/41]

maxon::MATH_HELPER_INSTANTIATE ( Clamp01  )

◆ MATH_HELPER_INSTANTIATE() [2/41]

maxon::MATH_HELPER_INSTANTIATE ( ATan2  )

◆ MATH_HELPER_INSTANTIATE() [3/41]

maxon::MATH_HELPER_INSTANTIATE ( Exp  )

◆ MATH_HELPER_INSTANTIATE() [4/41]

maxon::MATH_HELPER_INSTANTIATE ( Exp2  )

◆ MATH_HELPER_INSTANTIATE() [5/41]

maxon::MATH_HELPER_INSTANTIATE ( Ln  )

◆ MATH_HELPER_INSTANTIATE() [6/41]

maxon::MATH_HELPER_INSTANTIATE ( Log10  )

◆ MATH_HELPER_INSTANTIATE() [7/41]

maxon::MATH_HELPER_INSTANTIATE ( Log2  )

◆ MATH_HELPER_INSTANTIATE() [8/41]

maxon::MATH_HELPER_INSTANTIATE ( Gamma  )

◆ MATH_HELPER_INSTANTIATE() [9/41]

maxon::MATH_HELPER_INSTANTIATE ( Si  )

◆ MATH_HELPER_INSTANTIATE() [10/41]

maxon::MATH_HELPER_INSTANTIATE ( Sinc  )

◆ MATH_HELPER_INSTANTIATE() [11/41]

maxon::MATH_HELPER_INSTANTIATE ( Abs  )

◆ MATH_HELPER_INSTANTIATE() [12/41]

maxon::MATH_HELPER_INSTANTIATE ( Ceil  )

◆ MATH_HELPER_INSTANTIATE() [13/41]

maxon::MATH_HELPER_INSTANTIATE ( Floor  )

◆ MATH_HELPER_INSTANTIATE() [14/41]

maxon::MATH_HELPER_INSTANTIATE ( Round  )

◆ MATH_HELPER_INSTANTIATE() [15/41]

maxon::MATH_HELPER_INSTANTIATE ( ClampValueCustom  )

◆ MATH_HELPER_INSTANTIATE() [16/41]

maxon::MATH_HELPER_INSTANTIATE ( MinCustom  )

◆ MATH_HELPER_INSTANTIATE() [17/41]

maxon::MATH_HELPER_INSTANTIATE ( MaxCustom  )

◆ MATH_HELPER_INSTANTIATE() [18/41]

maxon::MATH_HELPER_INSTANTIATE ( Fract  )

◆ MATH_HELPER_INSTANTIATE() [19/41]

maxon::MATH_HELPER_INSTANTIATE ( Invert  )

◆ MATH_HELPER_INSTANTIATE() [20/41]

maxon::MATH_HELPER_INSTANTIATE ( FMod  )

◆ MATH_HELPER_INSTANTIATE() [21/41]

maxon::MATH_HELPER_INSTANTIATE ( MapRange  )

◆ MATH_HELPER_INSTANTIATE() [22/41]

maxon::MATH_HELPER_INSTANTIATE ( Inverse  )

◆ MATH_HELPER_INSTANTIATE() [23/41]

maxon::MATH_HELPER_INSTANTIATE ( SignNoTemplate  )

◆ MATH_HELPER_INSTANTIATE() [24/41]

maxon::MATH_HELPER_INSTANTIATE ( SmoothStep  )

◆ MATH_HELPER_INSTANTIATE() [25/41]

maxon::MATH_HELPER_INSTANTIATE ( BoxStep  )

◆ MATH_HELPER_INSTANTIATE() [26/41]

maxon::MATH_HELPER_INSTANTIATE ( Step  )

◆ MATH_HELPER_INSTANTIATE() [27/41]

maxon::MATH_HELPER_INSTANTIATE ( Quantize  )

◆ MATH_HELPER_INSTANTIATE() [28/41]

maxon::MATH_HELPER_INSTANTIATE ( Pow  )

◆ MATH_HELPER_INSTANTIATE() [29/41]

maxon::MATH_HELPER_INSTANTIATE ( Sqrt  )

◆ MATH_HELPER_INSTANTIATE() [30/41]

maxon::MATH_HELPER_INSTANTIATE ( Cbrt  )

◆ MATH_HELPER_INSTANTIATE() [31/41]

maxon::MATH_HELPER_INSTANTIATE ( Sin  )

◆ MATH_HELPER_INSTANTIATE() [32/41]

maxon::MATH_HELPER_INSTANTIATE ( Cos  )

◆ MATH_HELPER_INSTANTIATE() [33/41]

maxon::MATH_HELPER_INSTANTIATE ( Tan  )

◆ MATH_HELPER_INSTANTIATE() [34/41]

maxon::MATH_HELPER_INSTANTIATE ( Sinh  )

◆ MATH_HELPER_INSTANTIATE() [35/41]

maxon::MATH_HELPER_INSTANTIATE ( Cosh  )

◆ MATH_HELPER_INSTANTIATE() [36/41]

maxon::MATH_HELPER_INSTANTIATE ( Tanh  )

◆ MATH_HELPER_INSTANTIATE() [37/41]

maxon::MATH_HELPER_INSTANTIATE ( ASin  )

◆ MATH_HELPER_INSTANTIATE() [38/41]

maxon::MATH_HELPER_INSTANTIATE ( ACos  )

◆ MATH_HELPER_INSTANTIATE() [39/41]

maxon::MATH_HELPER_INSTANTIATE ( ATan  )

◆ MATH_HELPER_INSTANTIATE() [40/41]

maxon::MATH_HELPER_INSTANTIATE ( SafePow  )

◆ MATH_HELPER_INSTANTIATE() [41/41]

maxon::MATH_HELPER_INSTANTIATE ( SafeSqrt  )

◆ MAXON_ENUM_LIST() [48/95]

enum maxon::ANIMBLENDSTATE maxon::MAXON_ENUM_LIST ( ANIMBLENDSTATE  )

◆ MAXON_DECLARATION() [68/84]

maxon::MAXON_DECLARATION ( Class< BlendAnimationRef >  ,
AnimBlendClass  ,
"net.maxon.class.blendanimationref"   
)

◆ MAXON_REGISTRY() [43/60]

maxon::MAXON_REGISTRY ( BlendFunctionRef  ,
BlendFunctions  ,
"net.maxon.registry.blendfunction"   
)

BlendFunctions offers a registry to extend blend functions e.g. for the BlendAnimationInterface.

◆ ComplexGetReal() [1/2]

static T maxon::ComplexGetReal ( const Complex< T > &  val)
static

Get the real part of a value no matter if this is a Complex or Float value.

Parameters
[in]valinput value
Returns
real value

◆ ComplexGetReal() [2/2]

static T maxon::ComplexGetReal ( const T &  val)
static

Get the real part of a value no matter if this is a Complex or Float value.

Parameters
[in]valinput value
Returns
real value

◆ ComplexGetImag() [1/2]

static T maxon::ComplexGetImag ( const Complex< T > &  val)
static

Get the imaginary part of a value no matter if this is a Complex or Float value. In the latter case the function will return 0.0

Parameters
[in]valinput value
Returns
real value

◆ ComplexGetImag() [2/2]

static T maxon::ComplexGetImag ( const T &  val)
static

Get the imaginary part of a value no matter if this is a Complex or Float value. In the latter case the function will return 0.0

Parameters
[in]valinput value
Returns
real value

◆ ComplexSetReal() [1/2]

static void maxon::ComplexSetReal ( Complex< T1 > &  dst,
const T2 &  val 
)
static

Set the real part of a value no matter if this is a Complex or Float value.

Parameters
[in]dstdestination value
[in]valreal value to be set

◆ ComplexSetReal() [2/2]

static void maxon::ComplexSetReal ( T1 &  dst,
const T2 &  val 
)
static

Set the real part of a value no matter if this is a Complex or Float value.

Parameters
[in]dstdestination value
[in]valreal value to be set

◆ ComplexSetImag() [1/2]

static void maxon::ComplexSetImag ( Complex< T1 > &  dst,
const T2 &  val 
)
static

Set the imaginary part of a value no matter if this is a Complex or Float value. In the latter case the function will do nothing

Parameters
[in]dstdestination value
[in]valimaginary value to be set

◆ ComplexSetImag() [2/2]

static void maxon::ComplexSetImag ( T1 &  dst,
const T2 &  val 
)
static

Set the imaginary part of a value no matter if this is a Complex or Float value. In the latter case the function will do nothing

Parameters
[in]dstdestination value
[in]valimaginary value to be set

◆ MAXON_DATATYPE() [47/66]

maxon::MAXON_DATATYPE ( Complex32  ,
"net.maxon.datatype.complex32"   
)

◆ MAXON_DATATYPE() [48/66]

maxon::MAXON_DATATYPE ( Complex64  ,
"net.maxon.datatype.complex64"   
)

◆ MAXON_ENUM_FLAGS() [26/33]

enum maxon::FFT_FLAGS maxon::MAXON_ENUM_FLAGS ( FFT_FLAGS  )

◆ MAXON_ENUM_FLAGS() [27/33]

enum maxon::FFT_SUPPORT maxon::MAXON_ENUM_FLAGS ( FFT_SUPPORT  )

◆ MAXON_REGISTRY() [44/60]

maxon::MAXON_REGISTRY ( Class< FFTRef >  ,
FFTClasses  ,
"net.maxon.registry.fftclasses"   
)

Registry to register/iterate all available FFT implementations.

◆ MAXON_DATATYPE() [49/66]

maxon::MAXON_DATATYPE ( MatrixNxM32  ,
"net.maxon.datatype.matrixnxm32"   
)

◆ MAXON_DATATYPE() [50/66]

maxon::MAXON_DATATYPE ( MatrixNxM64  ,
"net.maxon.datatype.matrixnxm64"   
)

◆ MAXON_DATATYPE() [51/66]

maxon::MAXON_DATATYPE ( MatrixNxMComplex32  ,
"net.maxon.datatype.matrixnxmcomplex32"   
)

◆ MAXON_DATATYPE() [52/66]

maxon::MAXON_DATATYPE ( MatrixNxMComplex64  ,
"net.maxon.datatype.matrixnxmcomplex64"   
)

◆ TranslateRotationOrder()

ROTATIONORDER maxon::TranslateRotationOrder ( const Id &  type)

Translate and Id rotation order value into the corresponding enum value.

Parameters
[in]typeThe ordering Id value.
Returns
The matching ROTATIONORDER.

◆ MAXON_DATATYPE() [53/66]

maxon::MAXON_DATATYPE ( PRSMatrix64  ,
"net.maxon.neutron.datatype.psrmatrix"   
)

◆ MAXON_DATATYPE() [54/66]

maxon::MAXON_DATATYPE ( PRSMatrix32  ,
"net.maxon.math.datatype.prsmatrix32"   
)

◆ MAXON_ENUM_LIST() [49/95]

enum maxon::NURBSCURVE_CONTINUITY maxon::MAXON_ENUM_LIST ( NURBSCURVE_CONTINUITY  )

◆ MAXON_IMPLEMENTATION_SIMPLE_REGISTER() [4/5]

maxon::MAXON_IMPLEMENTATION_SIMPLE_REGISTER ( NURBSCurveWithContinuity< D >  )

◆ MAXON_ENUM_LIST() [50/95]

enum maxon::NURBSCURVE_KNOTMODE maxon::MAXON_ENUM_LIST ( NURBSCURVE_KNOTMODE  )

◆ MAXON_IMPLEMENTATION_SIMPLE_REGISTER() [5/5]

maxon::MAXON_IMPLEMENTATION_SIMPLE_REGISTER ( NURBSCurve< D >  )

◆ MAXON_DATATYPE() [55/66]

maxon::MAXON_DATATYPE ( Quaternion32  ,
"net.maxon.datatype.quaternion32"   
)

◆ MAXON_DATATYPE() [56/66]

maxon::MAXON_DATATYPE ( Quaternion64  ,
"net.maxon.datatype.quaternion64"   
)

◆ MatrixConvert()

void maxon::MatrixConvert ( SquareMatrix4d &  dest,
const Matrix &  src 
)

◆ MAXON_ENUM_LIST() [51/95]

enum maxon::PRIMITIVETYPE maxon::MAXON_ENUM_LIST ( PRIMITIVETYPE  )

◆ MAXON_DECLARATION() [69/84]

maxon::MAXON_DECLARATION ( Class< DistanceQueryRef >  ,
DistanceCalculator  ,
"net.maxon.geom.interface.distancequery.distancecalculator"   
)

◆ MAXON_REGISTRY() [45/60]

maxon::MAXON_REGISTRY ( CustomDataTagClass  ,
CustomDataTagClasses  ,
"net.maxon.mesh_misc.registry.customdatatagclasses"   
)

◆ MAXON_REGISTRY() [46/60]

maxon::MAXON_REGISTRY ( Class< CustomDataTagDisplayRef >  ,
CustomDataTagDisplayClasses  ,
"net.maxon.mesh_misc.registry.customdatatagdisplayclasses"   
)

◆ MAXON_DATATYPE() [57/66]

maxon::MAXON_DATATYPE ( MeshAttribute  ,
"net.maxon.mesh_misc.datatype.meshattribute"   
)

◆ MAXON_DATATYPE() [58/66]

maxon::MAXON_DATATYPE ( PolygroupInformation  ,
"net.maxon.meshattribute.gozpolyinformation"   
)

Declaration of a new DataType. This will be store inside the new mesh attribute

◆ MAXON_MESHATTRIBUTE()

maxon::MAXON_MESHATTRIBUTE ( PolygroupInformation  ,
POLYGROUP   
)

Declaration of the new MeshAttribute.

◆ MAXON_DATATYPE() [59/66]

maxon::MAXON_DATATYPE ( POLYGROUP_MESHATTRIBUTE  ,
"net.maxon.meshattribute.gozpolygroup"   
)

Declaration of the new DataTape for the mesh attribute.

◆ MAXON_DECLARATION() [70/84]

maxon::MAXON_DECLARATION ( Class< VoxelizationRef >  ,
PolyVoxelization  ,
"net.maxon.geom.interface.voxelization.polyvoxelization"   
)

◆ MAXON_ENUM_FLAGS() [28/33]

enum maxon::CORENODE_PORT_FLAGS maxon::MAXON_ENUM_FLAGS ( CORENODE_PORT_FLAGS  )

◆ MAXON_ENUM_LIST() [52/95]

enum maxon::PORT_DIR Int maxon::MAXON_ENUM_LIST ( PORT_DIR  )

◆ operator++()

PORT_DIR& maxon::operator++ ( PORT_DIR &  dir)

◆ Reverse() [5/5]

PORT_DIR maxon::Reverse ( PORT_DIR  dir)

Returns the reverse of the given direction. PORT_DIR::INPUT becomes PORT_DIR::OUTPUT and vice versa.

Parameters
[in]dirA direction.
Returns
The reverse of dir.

◆ MAXON_REGISTRY() [47/60]

maxon::MAXON_REGISTRY ( IconProvider  ,
IconProviders  ,
"net.maxon.registry.iconproviders"   
)

Registry for IconProvider, see there. You have to register your own provider if you want to use own icons with the IconProvider mechanism.

◆ GetUrlFromIconProviders()

Result<Url> maxon::GetUrlFromIconProviders ( const CString &  iconId)

◆ MAXON_ENUM_LIST() [53/95]

enum maxon::IOFORMAT maxon::MAXON_ENUM_LIST ( IOFORMAT  )

◆ ReadDocument() [1/6]

std::enable_if<GetCollectionKind<T>::value == COLLECTION_KIND::ARRAY, Result<void> >::type maxon::ReadDocument ( const Url &  url,
const Id &  id,
T &  object,
const DataDictionary &  dict = DataDictionary() 
)

◆ ReadDocument() [2/6]

std::enable_if<GetCollectionKind<T>::value != COLLECTION_KIND::ARRAY && !STD_IS_REPLACEMENT(same, T, Data), Result<void> >::type maxon::ReadDocument ( const Url &  url,
const Id &  id,
T &  object,
const DataDictionary &  dict = DataDictionary() 
)

◆ ReadDocument() [3/6]

std::enable_if<STD_IS_REPLACEMENT(same, T, Data), Result<void> >::type maxon::ReadDocument ( const Url &  url,
const Id &  id,
T &  object,
const DataDictionary &  dict = DataDictionary() 
)

◆ ReadDocument() [4/6]

std::enable_if<GetCollectionKind<T>::value == COLLECTION_KIND::ARRAY, Result<void> >::type maxon::ReadDocument ( UrlOrInputStream &&  urlOrStream,
const Id &  id,
T &  object,
IOFORMAT  format = IOFORMAT::DEFAULT,
const DataDictionary &  dict = DataDictionary() 
)

◆ ReadDocument() [5/6]

std::enable_if<GetCollectionKind<T>::value != COLLECTION_KIND::ARRAY && !STD_IS_REPLACEMENT(same, T, Data), Result<void> >::type maxon::ReadDocument ( UrlOrInputStream &&  urlOrStream,
const Id &  id,
T &  object,
IOFORMAT  format = IOFORMAT::DEFAULT,
const DataDictionary &  dict = DataDictionary() 
)

◆ ReadDocument() [6/6]

std::enable_if<STD_IS_REPLACEMENT(same, T, Data), Result<void> >::type maxon::ReadDocument ( UrlOrInputStream &&  urlOrStream,
const Id &  id,
T &  object,
IOFORMAT  format = IOFORMAT::DEFAULT,
const DataDictionary &  dict = DataDictionary() 
)

◆ WriteDocument() [1/4]

Result<void> maxon::WriteDocument ( const Url &  url,
OPENSTREAMFLAGS  flags,
const Id &  id,
const T &  object,
IOFORMAT  format = IOFORMAT::DEFAULT,
const DataDictionary &  dict = DataDictionary() 
)

◆ WriteDocument() [2/4]

std::enable_if<GetCollectionKind<T>::value == COLLECTION_KIND::ARRAY, Result<void> >::type maxon::WriteDocument ( const OutputStreamRef &  stream,
const Id &  id,
const T &  object,
IOFORMAT  format = IOFORMAT::DEFAULT,
const DataDictionary &  dict = DataDictionary() 
)

◆ WriteDocument() [3/4]

std::enable_if<STD_IS_REPLACEMENT(same, T, Data), Result<void> >::type maxon::WriteDocument ( const OutputStreamRef &  stream,
const Id &  id,
const T &  object,
IOFORMAT  format = IOFORMAT::DEFAULT,
const DataDictionary &  dict = DataDictionary() 
)

◆ WriteDocument() [4/4]

std::enable_if<GetCollectionKind<T>::value != COLLECTION_KIND::ARRAY && !STD_IS_REPLACEMENT(same, T, Data), Result<void> >::type maxon::WriteDocument ( const OutputStreamRef &  stream,
const Id &  id,
const T &  object,
IOFORMAT  format = IOFORMAT::DEFAULT,
const DataDictionary &  dict = DataDictionary() 
)

◆ MAXON_ENUM_LIST() [54/95]

enum maxon::PROFILER_POINT_TYPE maxon::MAXON_ENUM_LIST ( PROFILER_POINT_TYPE  )

◆ MAXON_ENUM_LIST() [55/95]

enum maxon::PROFILER_STATE maxon::MAXON_ENUM_LIST ( PROFILER_STATE  )

◆ MAXON_ENUM_LIST() [56/95]

enum maxon::PROFILER_CLOCK_MODE maxon::MAXON_ENUM_LIST ( PROFILER_CLOCK_MODE  )

◆ MAXON_DECLARATION() [71/84]

maxon::MAXON_DECLARATION ( maxon::Profiler *  ,
ProfilerInstance  ,
"net.maxon.profiler"   
)

◆ MAXON_ENUM_LIST() [57/95]

enum maxon::SELECTION_MODE UChar maxon::MAXON_ENUM_LIST ( SELECTION_MODE  )

◆ MAXON_ENUM_FLAGS() [29/33]

enum maxon::SELECTION_STATUS UChar maxon::MAXON_ENUM_FLAGS ( SELECTION_STATUS  )

◆ SCCCheckOutFile()

Result<void> maxon::SCCCheckOutFile ( const Url &  url,
Bool  outputError 
)

◆ SCCAddFile()

Result<void> maxon::SCCAddFile ( const Url &  url,
Bool  outputError 
)

◆ MAXON_REGISTRY() [48/60]

maxon::MAXON_REGISTRY ( SubData  ,
SubDatas  ,
"net.maxon.registry.subdatas"   
)

◆ MAXON_REGISTRY() [49/60]

maxon::MAXON_REGISTRY ( SubDataOperation  ,
SubDataOperations  ,
"net.maxon.registry.subdataoperations"   
)

◆ MAXON_ENUM_LIST() [58/95]

enum maxon::HTTPCODE maxon::MAXON_ENUM_LIST ( HTTPCODE  )

◆ MAXON_ENUM_LIST() [59/95]

enum maxon::SOCKETMODE maxon::MAXON_ENUM_LIST ( SOCKETMODE  )

◆ MAXON_ENUM_LIST() [60/95]

enum maxon::CONNECTIONMODE maxon::MAXON_ENUM_LIST ( CONNECTIONMODE  )

◆ MAXON_ENUM_LIST() [61/95]

enum maxon::CONNECTIONTYPE maxon::MAXON_ENUM_LIST ( CONNECTIONTYPE  )

◆ MAXON_DECLARATION_STRINGENCODING() [1/2]

maxon::MAXON_DECLARATION_STRINGENCODING ( "html"  ,
Html   
)

HTML

  • encodes characters from Utf32Char to UChar
  • decodes characters from UChar to Utf32Char

Details:

  • characters in the range 0..127 are encoded as single byte values
  • characters above127 are encoded into a sequence of bytes.
  • for special characters a character entity table is used to map the characters to a byte sequence see http://www.w3.org/TR/html5/syntax.html#named-character-references. For example $ is converted to &dollar;
  • Any other character is encoded by a sequence of characters with &#xhhhh; where each hhhh is the hex value representing the character in Unicode space.
  • The decoder reads any of these possible HTML hex value formats (d=decimal digit, h=hex digit):
    • &#d;
    • &#dd;
    • &#ddd;
    • &#dddd;
    • &#xh;
    • &#xhh;
    • &#xhhh;
    • &#xhhhh;
  • Also any known character entity name is decoded as well

Errors:
Returns an error if unkown byte codes outside the valid range are used.
HTML forbids the use of the characters with Universal Character Set/Unicode code points:

◆ MAXON_DECLARATION_STRINGENCODING() [2/2]

maxon::MAXON_DECLARATION_STRINGENCODING ( "punycode"  ,
Punycode   
)

◆ MAXON_ENUM_LIST() [62/95]

enum maxon::PROTOCOL maxon::MAXON_ENUM_LIST ( PROTOCOL  )

◆ MAXON_ENUM_LIST() [63/95]

enum maxon::WILDCARD_IPV4_ADDRESS_TYPE maxon::MAXON_ENUM_LIST ( WILDCARD_IPV4_ADDRESS_TYPE  )

◆ MAXON_ENUM_LIST() [64/95]

enum maxon::WILDCARD_IPV6_ADDRESS_TYPE maxon::MAXON_ENUM_LIST ( WILDCARD_IPV6_ADDRESS_TYPE  )

◆ MAXON_DECLARATION() [72/84]

maxon::MAXON_DECLARATION ( Class< SSHNetworkConnectionRef >  ,
NetworkConnectionSSHClass  ,
"net.maxon.class.networkconnectionssh"   
)

◆ MAXON_ENUM_LIST() [65/95]

enum maxon::SSLSOCKETTYPE maxon::MAXON_ENUM_LIST ( SSLSOCKETTYPE  )

◆ MAXON_ENUM_LIST() [66/95]

enum maxon::SSLPROTOCOLVERSION maxon::MAXON_ENUM_LIST ( SSLPROTOCOLVERSION  )

◆ MAXON_ENUM_FLAGS() [30/33]

enum maxon::SSLCERTREQUIREMENTS maxon::MAXON_ENUM_FLAGS ( SSLCERTREQUIREMENTS  )

◆ MAXON_ENUM_LIST() [67/95]

enum maxon::SSLFILETYPE maxon::MAXON_ENUM_LIST ( SSLFILETYPE  )

◆ MAXON_DECLARATION() [73/84]

maxon::MAXON_DECLARATION ( Class< SSLNetworkConnectionRef >  ,
NetworkConnectionSSLClass  ,
"net.maxon.class.networkconnectionssl"   
)

◆ MAXON_ENUM_LIST() [68/95]

enum maxon::OAUTHSIGNATUREMETHOD maxon::MAXON_ENUM_LIST ( OAUTHSIGNATUREMETHOD  )

◆ MAXON_ENUM_LIST() [69/95]

enum maxon::OAUTHHTTPMETHOD maxon::MAXON_ENUM_LIST ( OAUTHHTTPMETHOD  )

◆ MAXON_ENUM_LIST() [70/95]

enum maxon::OAUTHERRORCODE maxon::MAXON_ENUM_LIST ( OAUTHERRORCODE  )

◆ MAXON_DECLARATION() [74/84]

maxon::MAXON_DECLARATION ( Class< UrlRedirectRef >  ,
UrlRedirectClass  ,
"net.maxon.class.urlredirectclass"   
)

◆ operator==() [7/8]

Bool maxon::operator== ( const ResourceIdentifier &  lhs,
const ResourceIdentifier &  rhs 
)

◆ operator!=() [6/7]

Bool maxon::operator!= ( const ResourceIdentifier &  lhs,
const ResourceIdentifier &  rhs 
)

◆ operator==() [8/8]

Bool maxon::operator== ( const ServiceProviderDetails &  lhs,
const ServiceProviderDetails &  rhs 
)

◆ operator!=() [7/7]

Bool maxon::operator!= ( const ServiceProviderDetails &  lhs,
const ServiceProviderDetails &  rhs 
)

◆ MAXON_ENUM_LIST() [71/95]

enum maxon::HTTPMETHOD maxon::MAXON_ENUM_LIST ( HTTPMETHOD  )

◆ ConvertFromUnicodeToUtf8Url()

CString maxon::ConvertFromUnicodeToUtf8Url ( const StringEncodingRef &  urlEncoding,
const String &  src 
)

◆ MAXON_DECLARATION() [75/84]

maxon::MAXON_DECLARATION ( ComponentDescriptor  ,
CombinerHttpCodeComponents  ,
"net.maxon.component.combinerhttpcodecomponents"   
)

Implementation of CombinerInterface. Using this combiner ensures that all subscribers are called. The result is combined by an OR operation.

◆ MAXON_ENUM_LIST() [72/95]

enum maxon::HTTPREQUESTTYPE maxon::MAXON_ENUM_LIST ( HTTPREQUESTTYPE  )

◆ MAXON_DECLARATION() [76/84]

maxon::MAXON_DECLARATION ( Class< NetworkIpHandlerRef >  ,
NetworkIpHandlerClass  ,
"net.maxon.class.networkiphandler"   
)

object definitions

◆ MAXON_DECLARATION() [77/84]

maxon::MAXON_DECLARATION ( Class< NetworkHttpHandlerRef >  ,
NetworkHttpHandlerClass  ,
"net.maxon.class.networkhttphandler"   
)

◆ MAXON_DECLARATION() [78/84]

maxon::MAXON_DECLARATION ( Class< NetworkWebServerRef >  ,
NetworkWebServerClass  ,
"net.maxon.class.networkwebserver"   
)

◆ MAXON_ENUM_LIST() [73/95]

enum maxon::WEBSOCKETSTATE maxon::MAXON_ENUM_LIST ( WEBSOCKETSTATE  )

◆ MAXON_ENUM_LIST() [74/95]

enum maxon::WEBSOCKETTYPE maxon::MAXON_ENUM_LIST ( WEBSOCKETTYPE  )

◆ MAXON_ENUM_LIST() [75/95]

enum maxon::WEBSOCKET_OPCODE UChar maxon::MAXON_ENUM_LIST ( WEBSOCKET_OPCODE  )

◆ MAXON_DECLARATION() [79/84]

maxon::MAXON_DECLARATION ( Class< NetworkWebSocketConnectionRef >  ,
NetworkWebSocketConnectionClass  ,
"net.maxon.class.networkwebsocketconnection"   
)

◆ MAXON_DECLARATION() [80/84]

maxon::MAXON_DECLARATION ( Class< NetworkWebSocketSignalRef >  ,
NetworkWebSocketSignalClass  ,
"net.maxon.class.networkwebsocketsignal"   
)

◆ MAXON_DECLARATION() [81/84]

maxon::MAXON_DECLARATION ( Class< NetworkWebSocketServerRef >  ,
NetworkWebSocketServerClass  ,
"net.maxon.class.networkwebsocketserver"   
)

◆ MAXON_DECLARATION() [82/84]

maxon::MAXON_DECLARATION ( Class< NetworkWebSocketClientConnectionRef >  ,
NetworkWebSocketClientConnectionClass  ,
"net.maxon.class.networkwebsocketclientconnection"   
)

◆ MAXON_ENUM_FLAGS() [31/33]

enum maxon::ZEROCONFACTION maxon::MAXON_ENUM_FLAGS ( ZEROCONFACTION  )

◆ MAXON_ENUM_LIST() [76/95]

enum maxon::ZEROCONFMACHINESTATE maxon::MAXON_ENUM_LIST ( ZEROCONFMACHINESTATE  )

◆ MAXON_ENUM_LIST() [77/95]

enum maxon::ZEROCONFERROR maxon::MAXON_ENUM_LIST ( ZEROCONFERROR  )

◆ MAXON_INTERNED_ID() [1/2]

maxon::MAXON_INTERNED_ID ( "in"  ,
DefaultInIoNode   
)

◆ MAXON_INTERNED_ID() [2/2]

maxon::MAXON_INTERNED_ID ( "out"  ,
DefaultOutIoNode   
)

◆ MAXON_ATTRIBUTE() [12/12]

maxon::MAXON_ATTRIBUTE ( void  ,
AssetCategoryNodeContext  ,
"net.maxon.asset.category.nodecontext"   
)

Use this to set category or search by category.

CategoryAssetInterface::SetAssetCategory(asset, AssetCategoryNodeContext) iferr_return;
maxon::CategoryAssetInterface::SetAssetCategory
static MAXON_METHOD Result< void > SetAssetCategory(const AssetDescription &asset, const Id &category)

◆ MAXON_ENUM_LIST() [78/95]

enum maxon::NIMBUS_PATH maxon::MAXON_ENUM_LIST ( NIMBUS_PATH  )

◆ MAXON_DATATYPE() [60/66]

maxon::MAXON_DATATYPE ( WeakNimbusBaseRef  ,
"net.maxon.datatype.weaknimbusref"   
)

◆ MAXON_REGISTRY() [50/60]

maxon::MAXON_REGISTRY ( Class< CodeExchangeRef >  ,
CodeExchanges  ,
"net.maxon.registry.codeexchange"   
)

◆ MAXON_REGISTRY() [51/60]

maxon::MAXON_REGISTRY ( Class< CodeExchangeRef >  ,
CodeExchangesEnabled  ,
"net.maxon.registry.codeexchange_enabled"   
)

◆ MAXON_ENUM_LIST() [79/95]

enum maxon::PyStringEncodings maxon::MAXON_ENUM_LIST ( PyStringEncodings  )

◆ MAXON_ENUM_LIST() [80/95]

enum maxon::OWNERSHIP maxon::MAXON_ENUM_LIST ( OWNERSHIP  )

◆ operator/()

MAXON_ATTRIBUTE_FORCE_INLINE ErrorStorage maxon::operator/ ( const FunctionRegistration &  reg,
py::NativePyCFunctionWithKeywords  func 
)

◆ MAXON_REGISTRY() [52/60]

maxon::MAXON_REGISTRY ( Class< PyModuleRef >  ,
PyModules  ,
"net.maxon.python.registry.pymodules"   
)

◆ MAXON_REGISTRY() [53/60]

maxon::MAXON_REGISTRY ( Class< LibraryRef >  ,
CPythonLibs  ,
"net.maxon.python.registry.cpythonlibs"   
)

◆ PrivateExtractCPythonLibrary3()

py::CPythonLibraryRef maxon::PrivateExtractCPythonLibrary3 ( py::NativePyObject *  self)

◆ _Python3Output() [1/3]

void maxon::_Python3Output ( maxon::TARGETAUDIENCE  audience,
const Char *  str,
Int  line,
const Char *  file,
maxon::WRITEMETA  meta = maxon::WRITEMETA::DEFAULT 
)

◆ _Python3Output() [2/3]

void maxon::_Python3Output ( maxon::TARGETAUDIENCE  audience,
const maxon::String &  str,
Int  line,
const Char *  file 
)

◆ _Python3Output() [3/3]

void maxon::_Python3Output ( maxon::TARGETAUDIENCE  audience,
maxon::StringProxy *  proxy,
Int  line,
const Char *  file 
)

◆ PrivateRegisterCPythonFunc()

maxon::Error maxon::PrivateRegisterCPythonFunc ( const Char *  name,
py::NativePyCFunctionWithKeywords  underlyingFunc3,
BaseArray< NativePyCFunctionTable > &  functions3 
)

◆ PrivateCPyRefDiagnosticOutput()

void maxon::PrivateCPyRefDiagnosticOutput ( MAXON_SOURCE_LOCATION_DECLARATION  ,
const Char *  refName,
const py::CPyRef &  ref 
)

◆ GetSymbol()

static auto maxon::GetSymbol ( const DllRef &  dll,
const CString &  symbol 
)
static

◆ MAXON_ENUM_LIST() [81/95]

enum maxon::Errno int maxon::MAXON_ENUM_LIST ( Errno  )

◆ MAXON_ENUM_LIST() [82/95]

enum maxon::CONTAINS int maxon::MAXON_ENUM_LIST ( CONTAINS  )

◆ MAXON_ENUM_FLAGS() [32/33]

enum maxon::VMSETTINGS maxon::MAXON_ENUM_FLAGS ( VMSETTINGS  )

◆ MAXON_ENUM_LIST() [83/95]

enum maxon::VMINITSETTINGS maxon::MAXON_ENUM_LIST ( VMINITSETTINGS  )

◆ MAXON_ENUM_LIST() [84/95]

enum maxon::ERRORHANDLING maxon::MAXON_ENUM_LIST ( ERRORHANDLING  )

◆ DiagnosticOutputFlags()

void maxon::DiagnosticOutputFlags ( EntityBase::FLAGS  flags)

◆ DiagnosticOutputValueKind()

void maxon::DiagnosticOutputValueKind ( const DataType &  dt)

◆ MAXON_ENUM_LIST() [85/95]

enum maxon::DEFAULTRUNTIME maxon::MAXON_ENUM_LIST ( DEFAULTRUNTIME  )

◆ MAXON_REGISTRY() [54/60]

maxon::MAXON_REGISTRY ( Class< VirtualMachineRef >  ,
VirtualMachines  ,
"net.maxon.python.registry.virtualmachines"   
)

◆ MAXON_REGISTRY() [55/60]

maxon::MAXON_REGISTRY ( VmDebuggerConnectionRef  ,
VmDebuggerConnections  ,
"net.maxon.python.registry.vmdebuggerconnections"   
)

◆ MAXON_DECLARATION() [83/84]

maxon::MAXON_DECLARATION ( Class< VirtualMachineScopeRef >  ,
CPythonScope  ,
"net.maxon.python.virtualmachine.scope"   
)

◆ MAXON_REGISTRY() [56/60]

maxon::MAXON_REGISTRY ( VirtualMachineRef  ,
PythonVms  ,
"net.maxon.python.virtualmachines"   
)

◆ MAXON_REGISTRY() [57/60]

maxon::MAXON_REGISTRY ( Class< FilterRef >  ,
FilterClasses  ,
"net.maxon.renderfilter.registry.filterclasses"   
)

◆ MAXON_REGISTRY() [58/60]

maxon::MAXON_REGISTRY ( Class< FilterCommandQueueRef >  ,
FilterCommandQueueClasses  ,
"net.maxon.renderfilter.registry.filtercommandqueueclasses"   
)

◆ MAXON_REGISTRY() [59/60]

maxon::MAXON_REGISTRY ( Class< FilterContextRef >  ,
FilterContextClasses  ,
"net.maxon.renderfilter.registry.filtercontextclasses"   
)

◆ MAXON_REGISTRY() [60/60]

maxon::MAXON_REGISTRY ( Class< FilterImageRef >  ,
FilterImageClasses  ,
"net.maxon.renderfilter.registry.filterimageclasses"   
)

◆ ToBlock()

Block<const Byte> maxon::ToBlock ( CFDataRef  ref)

◆ GetCustomCFAllocator()

CFAllocatorRef maxon::GetCustomCFAllocator ( )

Returns a custom CFAllocator which only supports dealloc via DeleteMem.

Returns
Custom CFAllocator.

◆ GetSystemColorSpace()

CGColorSpaceRef maxon::GetSystemColorSpace ( )

◆ GetColorSpaceSRGB()

CGColorSpaceRef maxon::GetColorSpaceSRGB ( )

◆ CGImageToARGB()

Result<void> maxon::CGImageToARGB ( CGImageRef  image,
Int  width,
Int  height,
void *  buf 
)

◆ ToCFString() [1/2]

CFStrongRef<CFStringRef> maxon::ToCFString ( const String &  in)

Converts a String to CFStringRef.

Parameters
[in]inString object.
Returns
CFStrongRef (can contain nullptr).

◆ ToCFString() [2/2]

CFStrongRef<CFStringRef> maxon::ToCFString ( const CString &  in)

Converts a CString to CFStringRef.

Parameters
[in]inCString object.
Returns
CFStrongRef (can contain nullptr).

◆ CFToString()

String maxon::CFToString ( const CFStringRef  in)

Converts a CFStringRef to String.

Parameters
[in]inCFStringRef (can be nullptr).
Returns
String object.

◆ CreateCFString()

CFStringRef maxon::CreateCFString ( const String &  in)

◆ ToCFURL()

Result<CFStrongRef<CFURLRef> > maxon::ToCFURL ( const Url &  fn)

Converts a Url to CFURLRef.

Parameters
[in]fnUrl object.
Returns
CFURLRef (can be nullptr). Make sure to delete CfRelease(cfUrl) to free the object.

◆ CFURLToUrl()

Result<Url> maxon::CFURLToUrl ( const CFURLRef  fn)

◆ GetPreferencesPath()

Result<Url> maxon::GetPreferencesPath ( Bool  localUser)

◆ GetApplicationSupportPath()

Result<Url> maxon::GetApplicationSupportPath ( Bool  localUser)

◆ GetSysCtlString() [1/3]

Bool maxon::GetSysCtlString ( const char *  what,
const Block< Char > &  out_str 
)

◆ GetSysCtlString() [2/3]

Bool maxon::GetSysCtlString ( const char *  what,
Int32 &  out 
)

◆ GetSysCtlString() [3/3]

Bool maxon::GetSysCtlString ( const char *  what,
UInt64 &  out 
)

◆ MAXON_PREPROCESSOR_CONDITION()

maxon::MAXON_PREPROCESSOR_CONDITION ( defined(MAXON_TARGET_WINDOWS)  )

◆ MAXON_DECLARATION() [84/84]

maxon::MAXON_DECLARATION ( Class< Volume >  ,
VOLUME  ,
"net.maxon.volume.class.volume"   
)

◆ MAXON_ENUM_LIST() [86/95]

enum maxon::VOLUMESAMPLER maxon::MAXON_ENUM_LIST ( VOLUMESAMPLER  ,
"net.maxon.volume.datatype.enum.volumesampler"   
)

◆ MAXON_DATATYPE() [61/66]

maxon::MAXON_DATATYPE ( GridAccessorBase  ,
"net.maxon.volume.datatype.gridaccessorbaseref"   
)

◆ MAXON_ENUM_LIST() [87/95]

enum maxon::ITERATORTYPE maxon::MAXON_ENUM_LIST ( ITERATORTYPE  )

◆ MAXON_ENUM_LIST() [88/95]

enum maxon::TREEVOXELLEVEL maxon::MAXON_ENUM_LIST ( TREEVOXELLEVEL  )

◆ MAXON_ENUM_LIST() [89/95]

enum maxon::VOLUME_RAY_TYPE maxon::MAXON_ENUM_LIST ( VOLUME_RAY_TYPE  ,
"net.maxon.volume.datatype.enum.raytype"   
)

◆ MAXON_DATATYPE() [62/66]

maxon::MAXON_DATATYPE ( VolumeRayIntersectorBase  ,
"net.maxon.volume.datatype.volumerayintersectorbaseref"   
)

◆ MAXON_ENUM_FLAGS() [33/33]

enum maxon::POLYGONCONVERSIONFLAGS maxon::MAXON_ENUM_FLAGS ( POLYGONCONVERSIONFLAGS  ,
"net.maxon.volume.datatype.enum.polygonconversionflags"   
)

◆ MAXON_ENUM_LIST() [90/95]

enum maxon::MIXVECTORTYPE maxon::MAXON_ENUM_LIST ( MIXVECTORTYPE  ,
"net.maxon.volume.datatype.enum.mixvectortype"   
)

◆ MAXON_ENUM_LIST() [91/95]

enum maxon::SDFFILTERTYPE maxon::MAXON_ENUM_LIST ( SDFFILTERTYPE  ,
"net.maxon.volume.datatype.enum.sdffiltertype"   
)

◆ MAXON_ENUM_LIST() [92/95]

enum maxon::FILTERTYPE maxon::MAXON_ENUM_LIST ( FILTERTYPE  ,
"net.maxon.volume.datatype.enum.filtertype"   
)

◆ MAXON_ENUM_LIST() [93/95]

enum maxon::VECTORFILTERTYPE maxon::MAXON_ENUM_LIST ( VECTORFILTERTYPE  ,
"net.maxon.volume.datatype.enum.vectorfiltertype"   
)

◆ MAXON_ENUM_LIST() [94/95]

enum maxon::FILTERACCURACY maxon::MAXON_ENUM_LIST ( FILTERACCURACY  ,
"net.maxon.volume.datatype.enum.filteraccuracy"   
)

◆ MAXON_DATATYPE() [63/66]

maxon::MAXON_DATATYPE ( SDFFilterSettings  ,
"net.maxon.volume.datatype.sdffiltersettings"   
)

◆ MAXON_DATATYPE() [64/66]

maxon::MAXON_DATATYPE ( FilterSettings  ,
"net.maxon.volume.datatype.filtersettings"   
)

◆ MAXON_ENUM_LIST() [95/95]

enum maxon::RESAMPLEINTERPOLATIONTYPE maxon::MAXON_ENUM_LIST ( RESAMPLEINTERPOLATIONTYPE  ,
"net.maxon.volume.datatype.enum.resampleinterpolationtype"   
)

◆ MAXON_DATATYPE() [65/66]

maxon::MAXON_DATATYPE ( FieldSampleData  ,
"net.maxon.volume.datatype.fieldsampledata"   
)

◆ MAXON_DATATYPE() [66/66]

maxon::MAXON_DATATYPE ( VolumeConversionPolygon  ,
"net.maxon.volume.datatype.volumeconversionpolygon"   
)

Variable Documentation

◆ URLSCHEME_ASSET

const Id URLSCHEME_ASSET
extern

Scheme identifier for asset references as used by Asset API data structures.

The same asset could be referenced by the URLs "asset:///file_37cd8c8dadea1a6a~.c4d" and "asset:///file_37cd8c8dadea1a6a~.c4d?name=SDK Cube&db=sdkdatabase.db", where the optional parameters are only used in error messages when the asset URL does not resolve. Both URLs can be used to reference the asset.

See also
UrlScheme

◆ URLSCHEME_ASSETDB

const Id URLSCHEME_ASSETDB
extern

Scheme identifier for human readable asset references as shown to the user in GUIs.

This scheme is never used to store references. The location of an asset is unpacked into its asset category relations, e.g., asset:///file_37cd8c8dadea1a6a~.c4d -> assetdb:///tex/Surfaces/Dirt Scratches & Smudges/RustPaint0291_M.jpg.

See also
UrlScheme

◆ URLSCHEME_META

const Id URLSCHEME_META
extern

Scheme identifier for relative file links to the metadata of an asset in a asset repository.

See also
UrlScheme

◆ URLSCHEME_METASQ

const Id URLSCHEME_METASQ
extern

Scheme identifier for relative file links to the metadata of an asset in an SQL database.

See also
UrlScheme

◆ ID_MISSINGASSETS

const LiteralId ID_MISSINGASSETS
static

Special asset id to declare missing assets in the dependency list. if this id appears in the dependencies, then the dependency asset was missing when creating the asset.

◆ PRESET_DEFAULT_CATEGORY

constexpr LiteralId PRESET_DEFAULT_CATEGORY
staticconstexpr

◆ ID_MISSINGNODESPACE

const LiteralId ID_MISSINGNODESPACE
static

◆ ID_MISSINGPLUGIN

const LiteralId ID_MISSINGPLUGIN
static

◆ TestForBeginFunction

decltype(begin(std::declval<T&>())) TestForBeginFunction(OverloadRank1) ( OverloadRank1  )

◆ TestForEndFunction

decltype(end(std::declval<T&>())) TestForEndFunction(OverloadRank1) ( OverloadRank1  )

◆ NO_MATCH

const NO_MATCH_TYPE NO_MATCH
static

◆ g_privateDays

const UInt32 g_privateDays[2][12]
static

◆ MAXON_ENUM_ORDERED_FLAGS

struct maxon::Wires MAXON_ENUM_ORDERED_FLAGS

◆ SYSTEM_BYTEORDER

const BYTEORDER SYSTEM_BYTEORDER

Indicates the active byte order on this system.

◆ g_hasSSE2

Bool g_hasSSE2
extern

◆ g_hasSSE3

Bool g_hasSSE3
extern

◆ g_hasSSSE3

Bool g_hasSSSE3
extern

◆ g_hasSSE4_1

Bool g_hasSSE4_1
extern

◆ g_hasSSE4_2

Bool g_hasSSE4_2
extern

◆ g_hasAVX

Bool g_hasAVX
extern

◆ g_hasFMA

Bool g_hasFMA
extern

◆ g_hasAES

Bool g_hasAES
extern

◆ g_hasPCLMULQDQ

Bool g_hasPCLMULQDQ
extern

◆ g_hasAVX2

Bool g_hasAVX2
extern

◆ g_CpuYieldDelegate

MAXON_ATTRIBUTE_DLL_PUBLIC CpuYieldState::SwitchDelegate g_CpuYieldDelegate

◆ g_inCrashhandler

Bool g_inCrashhandler
extern

◆ DATADESCRIPTION_CATEGORY_DATA

const Id DATADESCRIPTION_CATEGORY_DATA

◆ DATADESCRIPTION_CATEGORY_UI

const Id DATADESCRIPTION_CATEGORY_UI

◆ DATADESCRIPTION_CATEGORY_STRING

const Id DATADESCRIPTION_CATEGORY_STRING

◆ DATADESCRIPTION_SCOPE_LOCAL

const Id DATADESCRIPTION_SCOPE_LOCAL

◆ INITIALIZEHASH

const UInt INITIALIZEHASH
static

◆ FINALIZEHASH

const UInt FINALIZEHASH
static

◆ VALIDATEHASH

const UInt VALIDATEHASH
static

◆ g_writableMemory

Char g_writableMemory[1024]
extern

◆ ADDOBSERVER_DEFAULTPRIORITY

constexpr Int ADDOBSERVER_DEFAULTPRIORITY
staticconstexpr

◆ NO_VALUE

const NO_VALUE_TYPE NO_VALUE
static

◆ UNKNOWNPROGRESS

const Float UNKNOWNPROGRESS
static

predefined value if the progress has an unknown time (in that case the progress shows a spinning status).

◆ DEFAULT_APPENDSIZE

const Int DEFAULT_APPENDSIZE
static

◆ LANGUAGE_ENGLISH_ID

const Id LANGUAGE_ENGLISH_ID
static

◆ Ignore

const IgnoredPlaceholder Ignore
static

◆ g_javaHelper

JavaHelper g_javaHelper
extern

◆ FAILED

const ERROR_FAILED FAILED
static

FAILED can be used for comparison with a Result value. It indicates the failure of an operation:

Result<void> Func()
{
if (...)
return OutOfMemoryError(MAXON_SOURCE_LOCATION);
return OK;
}
if (Func() == FAILED)
{
...
}
maxon::FAILED
static const ERROR_FAILED FAILED
Definition: resultbase.h:68

◆ returns_nonnull

const Error returns_nonnull

◆ g_freeThreadedStuff

HashSet<ThreadedUIUpdateBaseRef> g_freeThreadedStuff
static

◆ g_freeThreadedStuffLock

Spinlock g_freeThreadedStuffLock
static

◆ g_exitObservable

FunctionBaseRef g_exitObservable
static

◆ g_inShutDown

Bool g_inShutDown
static

◆ POINT_FUSE_EPS

const Float POINT_FUSE_EPS
static

◆ Mantissa

const UInt32 Mantissa[2048]
extern

◆ Offset

const UInt16 Offset[64]
extern

◆ Exponent

const UInt32 Exponent[64]
extern

◆ Base

const UInt16 Base[512]
extern

◆ Shift

const UChar Shift[512]
extern

◆ DYNAMICDEGREE

constexpr Int DYNAMICDEGREE
staticconstexpr

◆ EPSS

const Float EPSS
static

◆ MR

const Int MR
static

◆ MT

const Int MT
static

◆ MAXIT

const Int MAXIT
static

◆ EPS

const Float EPS
static

◆ g_enableInCodeProfiler

Bool g_enableInCodeProfiler
extern

◆ g_enableProfilerDumpRegistry

Bool g_enableProfilerDumpRegistry
extern

◆ g_enableProfilerDumpRegistryErrors

Bool g_enableProfilerDumpRegistryErrors
extern

◆ g_enableProfilerGetMethodNameTrace

Bool g_enableProfilerGetMethodNameTrace
extern

◆ URLSCHEME_RAMDISK

const Id URLSCHEME_RAMDISK
static

Scheme identifier for virtual file systems in RAM.

See also
UrlScheme

◆ NETWORK_DEFAULT_CONNECT_TIMEOUT

const TimeValue NETWORK_DEFAULT_CONNECT_TIMEOUT
static

The default timeout for network connections. Is -1 for the internal default value.

◆ NETWORK_DEFAULT_SESSION_TIMEOUT

const TimeValue NETWORK_DEFAULT_SESSION_TIMEOUT
static

The default timeout for network sessions. Is -1 for the internal default value.

◆ SOCKETTIMEOUT_INDEFINITELY

const TimeValue SOCKETTIMEOUT_INDEFINITELY
static

Constants for the timeout of NetworkIpInterface::OpenListener(), NetworkIpInterface::OpenWaitForIncoming(), NetworkIpInterface::OpenOutgoing().

◆ SOCKETTIMEOUT_NEVERBLOCK

const TimeValue SOCKETTIMEOUT_NEVERBLOCK
static

Constants for the timeout of NetworkIpInterface::OpenListener(), NetworkIpInterface::OpenWaitForIncoming(), NetworkIpInterface::OpenOutgoing().

◆ WILDCARD_IPV4_ADDRESS

const WILDCARD_IPV4_ADDRESS_TYPE WILDCARD_IPV4_ADDRESS
static

◆ WILDCARD_IPV6_ADDRESS

const WILDCARD_IPV6_ADDRESS_TYPE WILDCARD_IPV6_ADDRESS
static

◆ WILDCARD_IP_PORT

const Int WILDCARD_IP_PORT
static

Any IP port.

◆ ID_LOGGER_PYTHON

const Id ID_LOGGER_PYTHON
extern

◆ NATIVE_CO_MAXBLOCKS

const Int32 NATIVE_CO_MAXBLOCKS