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< IdAndVersionIdToIdAndVersion (const Id &id)
 
Result< IdIdAndVersionToId (const IdAndVersion &assetId)
 
Result< Tuple< AssetRepositoryRef, IdAndVersion, Bool > > IdToIdAndVersionWithRepository (const Id &id, const AssetRepositoryRef &lookupRepository)
 
Result< IdIdAndVersionToIdWithRepository (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 >
Fold (ITERATOR first, SENTINEL sentinel, V initialValue, BINARYOP op)
 
template<typename ITERABLE , typename V , typename BINARYOP >
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 StringStringInterface_GetAndCacheConstString (const wchar_t *str, Int len)
 
const StringStringInterface_GetAndCacheConstString (const Char *str, Int len, Int isUtf8)
 
constexpr Bool PrivateIsUtf8 (const char *str, Int len)
 
const Stringoperator""_s (const char *str, std::size_t cnt)
 
const Stringoperator""_s (const wchar_t *str, std::size_t cnt)
 
template<typename T >
String GlobalToString (const T &object, const FormatStatement *formatStatement, Bool checkDataType=true)
 
template<typename T , typename E >