Namespaces | Classes | Typedefs | Enumerations | Functions | Variables
maxon Namespace Reference
Library » BrowserLibrary » | VolumeObjectFunction » | Callbacks/Handlers | Threading

Detailed Description

The maxon namespace contains all declarations of the MAXON API.

Useful apibasemath extensions.

Namespaces

 BASE64_OPTIONS
 
 BlendFunctions
 
 BLOWFISHLEGACYENDECODER_OPTIONS
 
 CATEGORY
 
 Classes
 
 ColorProfiles
 
 ColorSpaces
 
 COMMAND
 
 CommandClasses
 
 CommandDataClasses
 
 CPythonLibs
 
 CryptographyOptions
 
 CustomDataTagClasses
 
 CustomDataTagDisplayClasses
 
 DATAFORMAT
 
 DATAFORMATBASEIDS
 
 DataFormatBaseReader
 
 DataFormatBaseWriter
 
 DataFormatReaderFactories
 
 DataFormatWriterFactories
 
 DESCRIPTION
 
 details
 
 Dimensions
 
 EXIFDATA
 
 FFTClasses
 
 FileFormatHandlers
 
 FILEFORMATPROPERTIES
 
 FileFormats
 
 HASH_HMAC
 
 HTTPANSWER
 
 HTTPREQUEST
 
 ImageBaseClasses
 
 IMAGEBASEPROPERTIES
 
 ImageChannelTypes
 
 ImageClasses
 
 ImageLayerClasses
 
 ImagePixelBlends
 
 ImagePixelStorageClasses
 
 IMAGEPROPERTIES
 
 ImageSaverClasses
 
 ImageTextureClasses
 
 LegacyCommandDataClasses
 
 Loggers
 
 LOGGERTYPEFLAGS
 
 LoggerTypes
 
 MACHINEINFO
 
 MEDIAFORMAT
 
 MEDIAINPUTPROPERTIES
 
 MEDIAOUTPUTURLPROPERTIES
 
 MEDIAPROPERTIES
 
 MEDIASESSION
 
 MEDIASTREAM
 
 MODULEVERSIONINFO
 
 NETWORKWEBSOCKETCONNECTIONPROPERTIES
 
 OBJECT
 
 ParametricTypes
 
 PixelFormats
 
 py
 
 py27
 
 PythonVms
 
 ReadArchiveClasses
 
 reflection
 
 rla
 
 specialtype
 
 SqlDatabaseClasses
 
 STREAMCONVERSION
 
 STREAMCONVERSIONFACTORYFLAGS
 
 StreamConversions
 
 STREAMCONVERSIONTEST
 
 STREAMFLAGS
 
 StringDecodings
 
 StringEncodings
 
 SubDataOperations
 
 SubDatas
 
 timezone
 
 Units
 
 URLFLAGS
 
 UTFTEXT_OPTIONS
 
 VirtualMachines
 
 VmDebuggerConnections
 
 WriteArchiveClasses
 

Classes

struct  ABIParamType
 
struct  ABIParamType< Block< T, STRIDED, MOVE > >
 
struct  ABIParamType< T, typename std::enable_if< std::is_enum< T >::value||std::is_integral< T >::value >::type >
 
struct  ABIParamType< T, typename std::enable_if< std::is_pointer< T >::value >::type >
 
struct  ABIParamType< T, typename std::enable_if< std::is_reference< T >::value >::type >
 
class  AbstractDataTypeFunctions
 
class  AdapterRoot
 
struct  AFloat
 
class  AggregatedError
 
class  AggregatedErrorInterface
 
struct  AInt
 
class  AioReaderInterface
 
class  AioServiceInterface
 
class  AioStatusInterface
 
class  AioWriterInterface
 
struct  AlignedStorage
 
struct  AlwaysFalse
 
struct  And
 
struct  And< false, REST... >
 
struct  And< true, REST... >
 
struct  And<>
 
struct  AppendToIndexSequence
 
struct  AppendToIndexSequence< std::index_sequence< SEQ... >, VALUE >
 
class  Application
 
class  ArrayAppendCache
 
class  ArrayBase
 
class  ArrayBase0
 
class  ArrayBurstTriePool
 
class  ArrayCloneHelper
 
class  ArrayCloneHelper< ARRAY & >
 
class  ArrayContainerInterface
 
class  ArrayContainerType
 
class  ArrayFactory
 
class  ArrayImpl
 
class  ArrayInterface
 
class  ArrayMap
 
class  ArrayMapHelper
 
class  ArrayMapHelper< K, V, true, COMPARE, ARRAY >
 
class  ArrayMapSelector
 
class  ArrayMapSortedArray
 
class  ArraySet
 
class  ArrayView
 
class  ArrayViewBase
 
struct  ArrayViewMember
 
class  ArrayViewType
 
class  ARWLock
 
class  AskPasswordInterface
 
class  AskPasswordMethod
 
class  Atomic16
 
class  Atomic32
 
class  Atomic64
 
class  Atomic8
 
class  AtomicBool
 
class  AtomicPtr
 
class  AudioObjectInterface
 
struct  AUInt
 
class  AutoIterator
 
class  AutoIterator< T[N]>
 
class  BaseArray
 
class  BaseArraySelector
 
class  BaseBitSet
 
class  BaseCollection
 
class  BaseInterfaces
 
class  BaseIterator
 
class  BaseIterator< COLLECTION, true >
 
class  BaseList
 
class  BaseListHead
 
class  BaseListLegacyNode
 
class  BaseListLink
 
struct  BaseListLinkPOD
 
class  BaseListNode
 
class  BaseListNode< EmptyClass, false >
 
class  BaseListNode< T, false >
 
class  BaseListNode< T, true >
 
class  BaseListNodeBase
 
class  BaseNURBSCurve
 
class  BaseRef
 
class  BaseRef< RawMem< T >, H >
 
class  BaseSort
 
class  BaseStreamInterface
 
class  BigInteger
 
class  BigIntegerInterface
 
class  BITS
 
class  BlendAnimationInterface
 
class  BlendFunctionInterface
 
class  BlendTweenInterface
 
class  Block
 
class  Block< Byte, false, false >
 
class  Block< const Byte, false, false >
 
class  BlockArray
 
class  BlockArraySelector
 
class  BlockBase
 
class  BlockBase< T, false >
 
class  BlockBufferAllocator
 
class  BoolLValue
 
class  BufferedBaseArraySelector
 
struct  BurstTrieBucket
 
struct  BurstTrieBucket< K, UnitType, SIZE >
 
class  BurstTrieMap
 
class  BurstTrieMapSelector
 
struct  BurstTrieNode
 
class  BurstTrieSet
 
class  Bytes
 
class  BytesValue
 
class  ByValueParam
 
struct  CArray
 
struct  CastHelper
 
struct  CastHelper< R, SRC, true >
 
class  CellData
 
struct  CellEdge
 
class  ChangeListInterface
 
struct  ChannelOffsetHelper
 
struct  CheckHasBase
 
struct  CheckHasBase< T, DEF, typename maxon::SFINAEHelper< void, typename std::decay< T >::type::HasBase >::type >
 
class  Class
 
class  ClassInterface
 
struct  Col3
 
struct  Col3< T, 1 >
 
struct  Col4
 
struct  Col4< T, 1 >
 
class  Collection
 
class  CollectorThread
 
class  ColorProfileConvertInterface
 
class  ColorProfileInterface
 
class  ColorSpaceInterface
 
class  CombinerInterface
 
class  CommandClassInterface
 
class  CommandDataInterface
 
class  CommandInteractionClassInterface
 
class  CommonIteratorTypes
 
class  CommonIteratorTypes< void, I1, I2 >
 
class  CommonLValue
 
class  CommonType
 
class  CompareTemplate
 
class  Complex
 
class  ComponentDescriptor
 
class  ComponentHelper
 
class  ComponentHelper< BASE >
 
class  ComponentHelper< BASE, I, REST... >
 
class  ComponentRoot
 
class  ComponentWithBase
 
class  ConcatForEachIterator
 
class  ConcatListView
 
class  ConcatListViewType
 
class  ConditionalForEachIterator
 
class  ConditionVariableDependency
 
class  ConditionVariableInterface
 
class  Configuration
 
class  ConstDataPtr
 
class  ConstIf
 
class  ConstIf< T, true >
 
class  ConstMatrixNxMInterface
 
class  ContiguousRangeMap
 
struct  ConvEdge
 
struct  ConversionTestSet
 
struct  ConvertFuncChannelHelper
 
struct  ConvexHullData
 
class  ConvexHullInterface
 
class  CopyWrapper
 
class  CpuYield
 
class  CpuYieldState
 
struct  CrashCallStackEntry
 
class  CrashHandler
 
class  CrashHandlerGlobals
 
class  CrashLogKey
 
struct  CrashModuleEntry
 
struct  CrashRegisterValue
 
class  CrashReportProperty
 
struct  CrashReportPropertyItem
 
class  CrashReportServices
 
struct  CrashReportState
 
struct  CrashThreadState
 
class  Crc32C
 
class  CryptographyStreamConversionInterface
 
class  CryptoKey
 
class  CryptoKeyInterface
 
class  CStdLibAllocator
 
class  CString
 
class  CStringCompare
 
class  CStringInterface
 
class  CustomAllocatorInterface
 
class  CustomDataTagClassInterface
 
class  CustomDataTagDisplayInterface
 
class  CustomSTLAllocator
 
class  Data
 
class  DataDescriptionDatabaseInterface
 
class  DataDescriptionDefinitionDatabaseImplInterface
 
class  DataDescriptionDefinitionDatabaseInterface
 
class  DataDescriptionDefinitionInterface
 
class  DataDescriptionInterface
 
class  DataDescriptionObjectInterface
 
class  DataDescriptionUIInterface
 
class  DataDictionaryInterface
 
class  DataDictionaryIterator
 
class  DataDictionaryIteratorInterface
 
struct  DataDictionaryKeySet
 
class  DataDictionaryObjectInterface
 
class  DataDictionaryReferenceObjectInterface
 
class  DataFormatBaseReaderInterface
 
class  DataFormatBaseWriterInterface
 
class  DataFormatReaderInterface
 
class  DataFormatWriterInterface
 
struct  DataMemBlock
 
class  DataPtr
 
class  DataSerializeInterface
 
class  DataSerializeReaderInterface
 
class  DataSerializeWriterInterface
 
class  DataType
 
class  DataTypeCache
 
class  DataTypeCacheInstance
 
class  DataTypeCacheInstance< T, POLICY, true >
 
class  DataTypeFunctions
 
class  DataTypeLib
 
class  DataTypeReferenceFunctions
 
class  Debugger
 
class  DebugHardwareBreakPointInterface
 
class  DecoratorInterface
 
struct  DeepImagePixelConstBuffer
 
struct  DeepImagePixelMutableBuffer
 
class  DefaultAllocator
 
class  DefaultCompare
 
class  DefaultDataTypeFunctions
 
class  DefaultDataTypeFunctions< T, DATATYPEMODE::BIG >
 
class  DefaultDataTypeFunctions< T, DATATYPEMODE::SMALL >
 
class  DefaultDataTypeFunctions< T, DATATYPEMODE::SMALLISPOD >
 
class  DefaultDataTypeFunctionsBase
 
struct  DefaultDataTypeFunctionsCapabilityFlags
 
class  DefaultDoc
 
struct  DefaultHashMapEntryHandlerBase
 
struct  DefaultNullValue
 
class  DefaultReification
 
class  DefaultSortedArray
 
class  Delaunay3DInterface
 
class  Delegate
 
class  Delegate< RESULT(ARGS...)>
 
class  DelegateBase
 
class  DelegateDataType
 
class  Dereference
 
class  Dereference< BaseRef< T, HANDLER >, false >
 
class  DESCRIBEFLAGS
 
class  DimensionInterface
 
class  Dispatch1
 
class  Dispatch1< ALGORITHM, std::tuple< TYPES... >, REIFICATION >
 
class  Dispatch2
 
class  Dispatch2< ALGORITHM, std::tuple< TYPES... >, REIFICATION >
 
class  DistanceQueryInterface
 
class  DllInterface
 
struct  DocStringMeta
 
struct  DrawDimension
 
struct  DrawDimension3d
 
struct  DrawPoint
 
struct  DrawPoint3d
 
struct  DrawRect
 
struct  DrawVolume
 
class  DynamicTupleImpl
 
class  DynamicTupleInterface
 
class  EagerDecoratorInterface
 
class  ElementPool
 
class  EmptyClass
 
class  EmptyVirtualClass
 
class  EnableIfFlag
 
class  EnumDataType
 
class  EqualityCompare
 
class  EraseIterator
 
class  EraseIterator< COLLECTION, SWAP_ERASE, false >
 
class  ErrnoErrorInterface
 
class  ErrorIndirectRef
 
class  ErrorInterface
 
class  ErrorPtr
 
struct  ErrorStorage
 
class  ExecuteOnMainThreadResult
 
class  ExecuteOnMainThreadResult< Result< RESULTVALUETYPE > >
 
class  ExecuteOnMainThreadResult< void >
 
class  ExecutionTime
 
class  ExifInterface
 
class  ExifStaticInterface
 
class  Factory< T(ARGS...)>
 
class  FactoryFactory
 
class  FactoryFunctions< Factory< T(ARGS...)>, SUPER >
 
class  FactoryFunctions< Factory< T(const DataDictionary &)>, SUPER >
 
class  FactoryInterface
 
class  FFTInterface
 
class  FId
 
class  FId< T, InternedId >
 
struct  FieldSampleData
 
class  FileFormatDetectionCacheInterface
 
class  FileFormatDetectionInterface
 
class  FileFormatErrorInterface
 
class  FileFormatHandlerInterface
 
class  FileFormatInterface
 
class  FileLoggerTypeInterface
 
class  FileMonitor
 
class  FileMonitorItemInterface
 
class  FileUtilities
 
class  FilterForEachIterator
 
struct  FilterSettings
 
struct  FindUniqueTupleIndex
 
struct  FindUniqueTupleIndex< SEARCHTYPE, Tuple< TYPES... > >
 
class  FixedBufferAllocator
 
class  FixedBufferAllocatorBase
 
struct  FixedBufferMemory
 
struct  FixedBufferMemory< SIZE, PARENT_ALLOCATOR, false >
 
class  FixedSizeBitSet
 
class  ForEach
 
class  ForEachIterator
 
class  FormatStatement
 
class  FormatTemplateHelper
 
class  FormatTemplateHelper< ARGCNT, const Char(&)[N]>
 
class  FormulaExecutionErrorInterface
 
class  FormulaNumberErrorInterface
 
class  FormulaParseErrorInterface
 
class  FormulaParserCacheInterface
 
class  FormulaParserInterface
 
struct  ForwardingDataPtr
 
class  ForwardRef
 
struct  ForwardResultPtr
 
class  Fraction
 
class  Function
 
class  Function< RESULT(ARGS...)>
 
class  FunctionBaseInterface
 
class  FunctionDataType
 
class  FunctionInterface
 
class  FunctionLib
 
class  FunctionNotImplementedErrorInterface
 
class  GenericArithmetic
 
class  GenericBaseArray
 
struct  GenericRegisterValue
 
class  GetCollectionKind
 
class  GetCollectionKind< COLLECTION, typename SFINAEHelper< void, typename std::decay< COLLECTION >::type::IsCollection >::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  GetDirectlyReferencedTypeCheckConstAndPtr
 
struct  GetHandler
 
struct  GetHandler< T, DEF, typename maxon::SFINAEHelper< void, typename std::decay< T >::type::Handler >::type >
 
struct  GetIndexSequenceElement
 
struct  GetIndexSequenceElement< std::index_sequence< VALUES... > >
 
struct  GetIteratorType
 
struct  GetIteratorType< T[N]>
 
struct  GetMemberType
 
struct  GetMemberType< MemberType< T, ID > >
 
struct  GetMemberType< MemberType< T, InternedId::NULL_VALUE > >
 
struct  GetNonConst
 
struct  GetNonConst< T, DEF, typename maxon::SFINAEHelper< void, typename std::decay< T >::type::NonConst >::type >
 
struct  GetPixelHandlerStruct
 
struct  GetReferencedType
 
struct  GetReferencedType< T, DEF, typename maxon::SFINAEHelper< void, typename std::decay< T >::type::ReferencedType >::type >
 
struct  GetSequenceElement
 
struct  GetSequenceElement< T, V0 >
 
struct  GetSequenceElement< T, V0, V1 >
 
struct  GetValueType
 
struct  GetValueType< T, DEF, typename maxon::SFINAEHelper< void, typename std::decay< T >::type::ValueType >::type >
 
class  Gibibytes
 
class  Gigabytes
 
class  GmlGraphInterface
 
struct  GmlNode
 
struct  GmlNodeAttribs
 
struct  GmlTarget
 
class  GmlWriterInterface
 
class  GradientInterface
 
struct  GradientKnot
 
class  GradientRenderDataInterface
 
class  GraphBase
 
class  GraphEdgeBase
 
class  GraphNodeBase
 
class  GridAccessorCreationInterface
 
class  GridAccessorInterface
 
class  GridAccessorRef
 
class  GridAccessorRef< Generic >
 
class  GridIteratorCreationInterface
 
class  GridIteratorInterface
 
class  GridIteratorRef
 
class  GUIDHASH
 
class  HalfFloat
 
class  HasBase
 
class  HashBitSet
 
class  HashMap
 
class  HashMapEntryBase
 
class  HashMapEntryBase< K, UnitType, ENTRY, ENTRY_HANDLER, HASHMAP_ENTRY_LAYOUT::KEY_VALUE >
 
class  HashMapEntryBase< K, UnitType, ENTRY, ENTRY_HANDLER, HASHMAP_ENTRY_LAYOUT::VALUE_KEY >
 
class  HashMapEntryBase< K, V, ENTRY, ENTRY_HANDLER, HASHMAP_ENTRY_LAYOUT::KEY_VALUE >
 
class  HashMapEntryBase< K, V, ENTRY, ENTRY_HANDLER, HASHMAP_ENTRY_LAYOUT::VALUE_KEY >
 
struct  HashMapKeyValuePair
 
class  HashMapSelector
 
class  HashMapStatistics
 
struct  HashMapValueKeyPair
 
class  HashSet
 
class  HasValueReceiver
 
class  HelperClass
 
class  HelperClass< SORTCLASS, ITERATOR, CONTENT, BASESORTFLAGS::MOVEANDCOPYOBJECTS >
 
class  HelperClass< SORTCLASS, ITERATOR, CONTENT, BASESORTFLAGS::NONE >
 
class  HierarchyIterator
 
class  HierarchyObjectInterface
 
class  HierarchyObjectIterator
 
class  Hours
 
class  HttpCodeErrorInterface
 
class  HybridMap
 
class  HybridMapGetIteratorHelper
 
class  HybridMapSelector
 
class  HybridSet
 
class  Id
 
struct  IDENT_VOID
 
class  IgnoredPlaceholder
 
class  IllegalArgumentErrorInterface
 
class  IllegalStateErrorInterface
 
class  ImageBaseInterface
 
struct  ImageBufferTemplate
 
class  ImageChannelInterface
 
class  ImageChannelTypeInterface
 
class  ImageFunctionsInterface
 
class  ImageInterface
 
class  ImageLayerInterface
 
class  ImagePixelBlendInterface
 
class  ImagePixelDeepImageStorageInterface
 
class  ImagePixelStorageInterface
 
struct  ImagePos
 
class  ImageTextureInterface
 
class  Indexable
 
class  IndexableType
 
class  IndexForEachIterator
 
struct  IndexInIndexSequence
 
struct  IndexInIndexSequence< I, std::index_sequence< X, LIST... > >
 
class  IndexIterator
 
class  IndexIteratorDefaultAccess
 
struct  IndexSequenceElement
 
struct  IndexSequenceElement< std::index_sequence< VALUES... >, INDEX >
 
class  InheritConst
 
class  InheritConst< T, const INHERIT_FROM >
 
class  InitializationFunctions
 
class  InOutputStreamInterface
 
class  InputStreamInterface
 
class  InterfaceDataTypeFunctions
 
struct  InterfacesBlock
 
class  InternedId
 
class  InternedIdInitializer
 
struct  IntFloat32
 
struct  IntFloat64
 
struct  IntType
 
struct  IntType< 1 >
 
struct  IntType< 2 >
 
struct  IntType< 4 >
 
struct  IntType< 8 >
 
class  IoBrowseInterface
 
class  IoConnectionInterface
 
class  IoDocument
 
class  IoDualInOutputStreamInterface
 
class  IoErrorInterface
 
class  IoFileInputHelper
 
class  IoFileOutputHelper
 
class  IoHandlerInterface
 
class  IoMemoryInterface
 
class  IoPipeInOutputStreamInterface
 
class  IoXmlNodeInterface
 
class  IoXmlParser
 
struct  IsAllocType
 
struct  IsAllocType< T, DEF, typename maxon::SFINAEHelper< void, typename std::decay< T >::type::IsAllocType >::type >
 
class  IsComplete
 
class  IsComplete< Class< T >, COUNTER >
 
class  IsCompleteBase
 
struct  IsDerived
 
class  IsErrorClass
 
struct  IsInterfaceType
 
struct  IsInterfaceType< T, DEF, typename maxon::SFINAEHelper< void, typename std::decay< T >::type::MTable >::type >
 
struct  IsIterable
 
struct  IsIterable< T[N]>
 
struct  IsNonvirtualInterfaceType
 
struct  IsNonvirtualInterfaceType< T, DEF, typename maxon::SFINAEHelper< void, typename std::decay< T >::type::IsNonvirtualInterfaceType >::type >
 
class  IsObjectReferenceClass
 
struct  IsPartiallyOrdered
 
struct  IsPartiallyOrdered< T, DEF, typename maxon::SFINAEHelper< void, typename std::decay< T >::type::PartiallyOrdered >::type >
 
class  IsReferenceClass
 
struct  IsSimdElementType
 
struct  IsSimdElementType< T, typename SFINAEHelper< void, typename T::VectorStrideType >::type >
 
struct  IsTriviallyEquatable
 
struct  IsTriviallyEquatable< InternedId >
 
struct  IsVirtualInterfaceType
 
struct  IsVirtualInterfaceType< T, DEF, typename maxon::SFINAEHelper< void, typename std::decay< T >::type::ProxyComponent >::type >
 
struct  IsZeroInitialized
 
struct  IsZeroInitialized< BaseArray< T, MINCHUNKSIZE, MEMFLAGS, ALLOCATOR > >
 
struct  IsZeroInitialized< Col3< T, 1 > >
 
struct  IsZeroInitialized< Data >
 
struct  IsZeroInitialized< DefaultAllocator >
 
struct  IsZeroInitialized< DrawDimension< T > >
 
struct  IsZeroInitialized< DrawPoint< T > >
 
struct  IsZeroInitialized< DrawRect< T > >
 
struct  IsZeroInitialized< Generic >
 
struct  IsZeroInitialized< InternedId >
 
struct  IsZeroInitialized< Mat2< T > >
 
struct  IsZeroInitialized< Mat3< T > >
 
struct  IsZeroInitialized< Range< T > >
 
struct  IsZeroInitialized< SqMat2< T > >
 
struct  IsZeroInitialized< SqMat3< T > >
 
struct  IsZeroInitialized< SqMat4< T > >
 
struct  IsZeroInitialized< TimeValue >
 
struct  IsZeroInitialized< Vec2< T, 1 > >
 
struct  IsZeroInitialized< Vec3< T, 1 > >
 
struct  IsZeroInitialized< Vec4< T, 1 > >
 
class  Iterable
 
struct  JavaCall
 
struct  JavaClass
 
class  JavaClassArray
 
class  JavaClassHash
 
class  JavaHelper
 
struct  JavaMember
 
class  JobBarrierInterface
 
class  JobBarrierInterfaceTemplate
 
class  JobBarrierRef
 
class  JobErrorInterface
 
class  JobGroupInterface
 
class  JobGroupRef
 
class  JobInterface
 
class  JobInterfaceTemplate
 
class  JobQueueInterface
 
class  JobQueueRef
 
class  JobRef
 
class  JobResultInterface
 
class  JobResultInterface< Result< RESULTVALUETYPE > >
 
class  JobResultInterface< Result< void > >
 
class  JobResultInterface< void >
 
class  JobResultRef
 
class  JobResultRef< Result< RESULTVALUETYPE > >
 
class  JobStatusInterface
 
struct  KDStackArray
 
class  KDTree
 
struct  KDTreeNearest
 
struct  KDTreeNode
 
class  Kibibytes
 
class  Kilobytes
 
struct  KnotInfo
 
class  LanguageInterface
 
struct  LayerSetCompare
 
class  LayerSetInterface
 
class  LazyInit
 
class  LegacyCommandClassInterface
 
class  LegacyCommandDataInterface
 
class  LexerInterface
 
class  LibraryInterface
 
class  LIMIT
 
class  LIMIT< Char >
 
class  LIMIT< Color32 >
 
class  LIMIT< Color64 >
 
class  LIMIT< ColorA32 >
 
class  LIMIT< ColorA64 >
 
class  LIMIT< Float32 >
 
class  LIMIT< Float64 >
 
class  LIMIT< Int16 >
 
class  LIMIT< Int32 >
 
class  LIMIT< Int64 >
 
class  LIMIT< UChar >
 
class  LIMIT< UInt16 >
 
class  LIMIT< UInt32 >
 
class  LIMIT< UInt64 >
 
class  LIMIT< Vector2d32 >
 
class  LIMIT< Vector2d64 >
 
class  LIMIT< Vector32 >
 
class  LIMIT< Vector4d32 >
 
class  LIMIT< Vector4d64 >
 
class  LIMIT< Vector64 >
 
class  LinearCongruentialRandom
 
class  ListView
 
class  ListViewRef
 
class  ListViewType
 
class  LiteralId
 
struct  LoadRuntime
 
class  LocalDateTime
 
class  LocalStringStorage
 
class  LockedResourceHelper
 
class  LockedResourceMap
 
struct  LockTraits
 
struct  LockTraits< Spinlock >
 
class  LoggerInterface
 
struct  LoggerLine
 
class  LoggerTypeInterface
 
class  LRUHashMap
 
class  MachineInterface
 
class  MachinesInterface
 
class  MapBase
 
class  MapBase0
 
class  MapCloneHelper
 
class  MapCloneHelper< MAP & >
 
class  MapForEachIterator
 
class  MapImpl
 
class  MapInterface
 
struct  Mat2
 
struct  Mat3
 
class  Match
 
class  Match< Int >
 
struct  MathFuncHelper
 
struct  MathFuncHelper< Col3< T >, FUNC >
 
struct  MathFuncHelper< Col4< T >, FUNC >
 
struct  MathFuncHelper< Vec2< T >, FUNC >
 
struct  MathFuncHelper< Vec3< T >, FUNC >
 
struct  MathFuncHelper< Vec4< T >, FUNC >
 
class  MatrixNxM
 
class  MatrixNxMInterface
 
class  MaximalElements
 
class  Mebibytes
 
class  MediaBaseInterface
 
class  MediaConverterErrorInterface
 
class  MediaConverterInterface
 
class  MediaInputInterface
 
class  MediaOutputInterface
 
class  MediaOutputTextureInterface
 
class  MediaOutputUrlInterface
 
class  MediaSessionFileFormatHandlerInterface
 
class  MediaSessionInterface
 
class  MediaSessionProgressInterface
 
class  MediaSessionWrongTypeErrorInterface
 
class  MediaStreamAudioDataExportInterface
 
class  MediaStreamAudioDataImportInterface
 
class  MediaStreamEOFErrorInterface
 
class  MediaStreamExifDataInterface
 
class  MediaStreamFormatInterface
 
class  MediaStreamImageBaseInterface
 
class  MediaStreamImageDataExportInterface
 
class  MediaStreamImageDataForwardImportInterface
 
class  MediaStreamImageDataImportInterface
 
class  MediaStreamInterface
 
class  MediaStreamPropertiesInterface
 
class  Megabytes
 
struct  Member
 
struct  MemberDetectorHelper
 
class  MemberType
 
class  MemberType< T &&, ID >
 
class  MemberType< T &, ID >
 
struct  MemoryMetadataProxy
 
class  MergeSegment
 
class  MeshAttribute
 
class  MeshAttributeClassInterface
 
struct  MeshDistanceData
 
class  Microseconds
 
class  MigratedCommandClassInterface
 
class  Milliseconds
 
class  Minutes
 
class  Misc
 
class  ModuleVersionInfoInterface
 
class  MoveDataPtr
 
class  MoveHelper
 
class  MoveHelper< SOURCEITERATOR, DESTITERATOR, CONTENT, false, false >
 
class  MoveHelper< SOURCEITERATOR, DESTITERATOR, CONTENT, false, true >
 
class  MoveHelper< SOURCEITERATOR, DESTITERATOR, CONTENT, true, false >
 
class  MoveHelper< SOURCEITERATOR, DESTITERATOR, CONTENT, true, true >
 
class  MultiIndex
 
class  MultiIndexBuilder
 
class  MultiplicativePromotion
 
class  MultiplicativePromotion< GenericArithmetic, GenericArithmetic, true >
 
class  MultiplicativePromotion< GenericArithmetic, T, true >
 
class  MultiplicativePromotion< T, GenericArithmetic, true >
 
class  MultiplicativePromotion< T1, T2, false >
 
class  NamedTuple
 
class  Nanoseconds
 
class  NestedForEachIterator
 
class  NetworkAdapterInterface
 
class  NetworkConnectionInterface
 
class  NetworkErrorInterface
 
class  NetworkHttpHandlerInterface
 
class  NetworkIpAddr
 
struct  NetworkIpAddressStruct
 
class  NetworkIpAddrInterface
 
class  NetworkIpAddrPort
 
class  NetworkIpAddrPortInterface
 
class  NetworkIpHandlerInterface
 
class  NetworkIpInterface
 
class  NetworkOAuthSessionInterface
 
class  NetworkProtocolJSONInterface
 
class  NetworkProxyInterface
 
struct  NetworkSockAddrIn
 
class  NetworkTcpConnectionInterface
 
struct  NetworkTcpConnectionOptions
 
class  NetworkTcpInterface
 
class  NetworkTcpServerInterface
 
class  NetworkTcpSocketInterface
 
class  NetworkUdpBoundSocketInterface
 
class  NetworkUdpChannelInterface
 
struct  NetworkUdpChannelOptions
 
class  NetworkUdpInterface
 
class  NetworkUdpSenderInterface
 
struct  NetworkUdpSenderOptions
 
class  NetworkUdpServerInterface
 
struct  NetworkUdpServerOptions
 
class  NetworkUdpSocketInterface
 
class  NetworkWebServerInterface
 
class  NetworkWebSocketClientConnectionInterface
 
class  NetworkWebSocketConnectionInterface
 
class  NetworkWebSocketServerInterface
 
class  NetworkWebSocketSignalInterface
 
class  NetworkZeroConfBrowserInterface
 
class  NetworkZeroConfInterface
 
class  NetworkZeroConfServiceInterface
 
class  NoErrorPtr
 
class  NonConstArray
 
class  NonConstMap
 
class  NonConstSet
 
class  NSSystemErrorInterface
 
class  NullAllocator
 
class  NullptrErrorInterface
 
class  NullValueDetector
 
class  NullValueFunctions
 
class  NullValueFunctions< Result< T > >
 
class  NullValueFunctionsHelper
 
class  NullValueFunctionsHelper< const T & >
 
class  NullValueFunctionsHelper< T & >
 
class  NullValueTypeHelper
 
class  NullValueTypeHelper< const T & >
 
class  NullValueTypeHelper< T & >
 
class  NullValueZeroInitializedHelper
 
class  NullValueZeroInitializedHelper< const T & >
 
class  NullValueZeroInitializedHelper< T & >
 
class  NURBSCurve
 
class  Object
 
class  ObjectConstructor
 
class  ObjectConstructor< T, false >
 
class  ObservableBaseInterface
 
class  ObservableImplRef
 
class  ObservableNotifyRef
 
class  ObservableNotifyRef< Delegate< RESULT(ARGS...)> >
 
class  ObservableNotifyRef< Delegate< RESULT(void)> >
 
class  ObservableRef
 
class  ObservableStaticInterface
 
class  ObserverObjectInterface
 
class  OpaqueBase
 
class  OpaquePtr
 
class  Opt
 
class  Opt< const T & >
 
class  Opt< T & >
 
class  Opt< T && >
 
struct  Or
 
struct  Or< T >
 
struct  Or< T, X, Y... >
 
class  OutOfMemoryErrorInterface
 
class  OutputStreamInterface
 
class  ParallelFor
 
class  ParallelImage
 
class  ParallelSort
 
struct  ParameterPack
 
struct  ParameterPack< T, REST... >
 
class  ParameterType
 
class  ParametricTypeInterface
 
class  ParseHelper
 
class  PerformanceBaseArray
 
struct  PixelConstBuffer
 
struct  PixelDepthInfo
 
struct  PixelDepthInfo< Pix16f >
 
struct  PixelDepthInfo< Pix16s >
 
struct  PixelDepthInfo< Pix16u >
 
struct  PixelDepthInfo< Pix32f >
 
struct  PixelDepthInfo< Pix32s >
 
struct  PixelDepthInfo< Pix32u >
 
struct  PixelDepthInfo< Pix64f >
 
struct  PixelDepthInfo< Pix8s >
 
struct  PixelDepthInfo< Pix8u >
 
class  PixelFormatDynamicInterface
 
class  PixelFormatGroupInterface
 
class  PixelFormatIndexedColorInterface
 
class  PixelFormatInterface
 
class  PixelFormatIterator
 
class  PixelFormatsInterface
 
class  PixelFormatTemplateBase
 
struct  PixelMutableBuffer
 
class  Pointer
 
class  PointerArray
 
class  PointerBurstTriePool
 
class  PointerHandler
 
class  PointsToVolumeListInterface
 
class  PolyData
 
struct  PredicateMatcher
 
class  PreviewImageCustomGui
 
class  PreviewImageData
 
struct  PrimitiveInformation
 
class  PrivateDummyFree
 
class  PrivateGetFIdKeyType
 
class  PrivateGetFIdKeyType< const char(&)[N]>
 
class  PrivateGetMapKey
 
class  PrivateGetMapKeyHelper
 
class  PrivateIdSwitch
 
class  PrivateIsErrorClassHelper
 
class  PrivateIsErrorClassHelper< T, true >
 
class  PrivateOpaque
 
class  PrivateOpaque< T *, void >
 
class  PrivateOpaque< T, typename SFINAEHelper< void, typename T::ReferencedType >::type >
 
class  PrivateOverloadRank0
 
class  PrivateOverloadRank1
 
class  PrivateOverloadRank2
 
class  PrivateOverloadRank3
 
class  PrivateOverloadRank4
 
class  PrivateOverloadRank5
 
struct  PrivateSelfHelper
 
struct  PrivateSelfHelperBase
 
class  ProfileManagerInterface
 
class  Profiler
 
class  ProfilerConstant
 
class  ProfilingPoint
 
struct  ProfilingPointHelper
 
class  ProgressMonitorInterface
 
class  Protected
 
class  PseudoRandom
 
class  PyModuleInterface
 
class  Quaternion
 
class  Queue
 
class  RamDiskInterface
 
class  Range
 
class  RangeMap
 
class  RangeSet
 
struct  RangeSetPair
 
struct  RawMem
 
class  ReadArchiveInterface
 
class  ReaderRef
 
class  ReaderRef< Utf32Char >
 
class  RefCompare
 
class  RefCompare< true, false >
 
class  RefCompare< true, true >
 
class  RefCountedCString
 
class  RefCountHashMap
 
class  RefCountHashMapDefaultHandler
 
class  Registry
 
class  RegistryDefinition
 
class  RegistryModuleDefinition
 
class  RegistryModuleDefinition< REG, Tuple< DEPS... > >
 
class  RegularExpressionInterface
 
struct  RepeatingPredicateMatcher
 
class  ResolveInterface
 
class  Resource
 
struct  ResourceIdentifier
 
class  RESTRICT
 
class  Result
 
class  ResultBase
 
class  ResultBase< T & >
 
class  ResultBase< void >
 
class  ResultIteratorFunctions
 
class  ResultMemT
 
struct  ResultOffsetHelper
 
class  ResultOk
 
class  ResultOk< T & >
 
class  ResultOk< void >
 
class  ResultRef
 
class  ResultSuper
 
class  ResultSuper< T &, typename SFINAEHelper< void, typename T::template ResultFunctions< ResultBase< T & > > >::type >
 
class  ResultSuper< T, typename SFINAEHelper< void, typename T::template ResultFunctions< ResultBase< T > > >::type >
 
struct  ReuseData
 
class  ReuseResourceTemplate
 
class  ReverseIterator
 
class  RingBuffer
 
class  RuleParserInterface
 
class  RunLoop
 
struct  Runtime
 
struct  RWSpinlock
 
class  ScopedARWReadLock
 
class  ScopedARWWriteLock
 
class  ScopedLock
 
class  ScopedLockPair
 
class  ScopedReadLock
 
class  ScopedWriteLock
 
struct  SDFFilterSettings
 
class  Seconds
 
class  SecureRandom
 
struct  SequenceElement
 
struct  SequenceElement< T, 0, VALUE, REST... >
 
struct  SequenceMatcher
 
struct  Serializer
 
class  SerialJobQueueInterface
 
class  SerialJobQueueRef
 
class  ServiceAnnouncementInterface
 
class  ServiceAnnouncementRequestInterface
 
class  ServiceBusInterface
 
struct  ServiceDiscovery
 
class  ServiceIOJobQueueInterface
 
class  ServiceIOJobQueueRef
 
struct  ServiceProviderDetails
 
class  ServiceSubscriptionInterface
 
class  ServiceSubscriptionRequestInterface
 
class  SetBase
 
class  SetBase0
 
class  SetCloneHelper
 
class  SetCloneHelper< SET & >
 
class  SetContainerInterface
 
class  SetContainerType
 
class  SetImpl
 
class  SetInterface
 
struct  SetPixelHandlerStruct
 
class  SetUsedFrameworks
 
class  SFINAEHelper
 
class  SharedObject
 
class  SharedRef
 
class  SharedRefBase
 
class  SharedRefHelper
 
class  SharedRefHelper< SharedObject< REFCLASS > >
 
class  ShutdownErrorInterface
 
class  SimdBlock
 
struct  SimdInfo
 
class  SimpleParallelSort
 
class  SimpleSort
 
class  SingletonForEachIterator
 
class  SingleValueReceiver
 
class  SmtpErrorInterface
 
class  SmtpMailInterface
 
struct  SmtpReceiver
 
class  SortedArray
 
class  SourceControlChangeEntry
 
class  SourceControlInterface
 
class  SourceLocation
 
struct  Spinlock
 
struct  SplineDistanceData
 
class  SqlDatabaseInterface
 
struct  SqMat2
 
struct  SqMat3
 
struct  SqMat4
 
class  SSHInterface
 
class  SSHNetworkConnectionInterface
 
class  SSLInterface
 
class  SSLNetworkConnectionInterface
 
class  StackBufferAllocator
 
class  StackTrace
 
struct  StandardType
 
struct  StandardType< T, true >
 
class  StaticJobArray
 
class  StaticJobGroupInterface
 
class  StaticJobGroupRef
 
class  StreamConversionHelper
 
class  StreamConversionInterface
 
class  String
 
class  StringConversion
 
class  StringCount
 
class  StringDecodingInterface
 
class  StringEncodingInterface
 
class  StringEnd
 
class  StringInterface
 
class  StringPosition
 
class  StringProxy
 
class  StringTemplate
 
class  StrongACOWRefHandler
 
class  StrongCOWRefHandler
 
class  StrongReferenceCounter
 
class  StrongRefHandler
 
class  SubDataInterface
 
class  SubDataOperationInterface
 
class  SubMenuEntry
 
class  Substitute
 
class  Substitute< T &&, R >
 
class  Substitute< T &, R >
 
struct  SubstituteReferenceByPointer
 
struct  SubstituteReferenceByPointer< T & >
 
struct  SubstituteReferenceByPointer< T && >
 
struct  Sum
 
struct  Sum< X, Y... >
 
struct  Sum<>
 
class  SuppressFloatingPointChecks
 
class  SymbolificationInterface
 
class  SynchronizedValue
 
class  SysCharArray
 
class  System
 
class  SystemErrorInterface
 
class  SystemProcessInterface
 
class  SystemProcessKilledErrorInterface
 
class  SystemProcessObjectInterface
 
class  SystemProcessOperationErrorInterface
 
class  TaggedBaseRef
 
class  Tebibytes
 
class  Terabytes
 
struct  TestForCopyFromMember
 
struct  Tetrahedron
 
class  ThreadCancelledErrorInterface
 
class  ThreadedUIUpdate
 
class  ThreadedUIUpdateBase
 
class  ThreadedUIUpdateRef
 
class  ThreadInterface
 
class  ThreadInterfaceTemplate
 
class  ThreadLocalDestructiblePointer
 
class  ThreadLocalPointer
 
class  ThreadReferencedError
 
class  ThreadRefTemplate
 
class  ThreadResultRef
 
class  ThreadResultRef< Result< RESULTVALUETYPE > >
 
class  ThreadSafePtr
 
class  ThreadSafeRef
 
class  TimerInterface
 
class  TimeStamp
 
struct  TimeStampMap
 
class  TimeValue
 
class  ToStringHelper2
 
class  ToStringHelper2< T, false >
 
class  ToStringHelper2< T, true >
 
class  TreeMap
 
class  TreeMapParent
 
class  TreeMapParent< PARENT, true >
 
class  TrivialConstDataPtr
 
class  Tuple
 
class  Tuple<>
 
class  TupleDataType
 
struct  TupleElementCompare
 
struct  TupleElementEquals
 
struct  TupleElementLessThan
 
class  TupleValue
 
struct  TypeArguments
 
class  UInteger
 
class  UInteger< SIZEOF(UIntegerBase) *8 >
 
struct  UIntType
 
struct  UIntType< 1 >
 
struct  UIntType< 2 >
 
struct  UIntType< 4 >
 
struct  UIntType< 8 >
 
struct  Undefined
 
class  UnexpectedErrorInterface
 
class  UnicodeUtils
 
class  UniqueRefHandler
 
class  UnitInterface
 
class  UnitTestComponent
 
class  UnitTestErrorInterface
 
class  UnitTestInterface
 
class  UnitType
 
class  UniversalDateTime
 
class  UnknownErrorInterface
 
class  UnknownFileSizeErrorInterface
 
class  UnregisteredDataTypeErrorInterface
 
class  UnresolvedErrorInterface
 
class  UnsupportedArgumentErrorInterface
 
class  UnsupportedOperationErrorInterface
 
class  UpdateRegionObserver
 
class  Url
 
class  UrlFileCacheEntryInterface
 
class  UrlFileCacheInterface
 
class  UrlInterface
 
class  UrlOrStream
 
class  UserLoggerTypeInterface
 
class  Uuid
 
class  UuidInterface
 
struct  ValueComparePredicate
 
struct  ValueKindHelper
 
struct  ValueKindHelper< Object, false >
 
struct  ValueKindHelper< T *, REF >
 
struct  ValueKindHelper< T, true >
 
struct  ValuePredicate
 
struct  Vec2
 
struct  Vec2< T, 1 >
 
struct  Vec3
 
struct  Vec3< T, 1 >
 
struct  Vec4
 
struct  Vec4< T, 1 >
 
class  Vector2f64
 
class  Vector4f32
 
class  Vector4f64
 
class  Vector4i32
 
class  Vector8f32
 
class  ViewIterator
 
struct  ViewIteratorMember
 
class  VirtualMachineInterface
 
class  VirtualMachineScopeInterface
 
class  VmDebuggerConnectionInterface
 
struct  VolumeCommandData
 
struct  VolumeConversionPolygon
 
class  VolumeInterface
 
class  VolumeToolsInterface
 
class  Voronoi3DInterface
 
class  VoxelizationInterface
 
class  WeakRef
 
struct  WeakRefBase
 
class  WeakRefServices
 
struct  WeakRefTargetBase
 
class  WriteArchiveInterface
 
class  WriterRef
 
class  WriterRef< Utf32Char >
 
class  XformListView
 
class  XformListViewLevels
 
class  XformListViewType
 
class  ZipForEachIterator
 

Typedefs

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 OverloadRank0 = PrivateOverloadRank0 *
 
using OverloadRank1 = PrivateOverloadRank1 *
 
using OverloadRank2 = PrivateOverloadRank2 *
 
using OverloadRank3 = PrivateOverloadRank3 *
 
using OverloadRank4 = PrivateOverloadRank4 *
 
using OverloadRank5 = PrivateOverloadRank5 *
 
using OverloadRankMax = OverloadRank5
 
using InitMTable = void(*)()
 
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 AtomicVoidPtr = AtomicPtr< void >
 
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 >
 
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 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, Bool > >
 
using VariadicIdsType = BaseArray< VariadicIdsElement >
 
using ContextVarTuple = Tuple< DataDictionary, GetDataCallbackType >
 
using ContextVarsMap = HashMap< Id, ContextVarTuple >
 
using ProcessEnumListDelegate = Delegate< Result< void >(const Id &epId, const DataDictionary &guiEntry, const AssetRepositoryRef &repository, const ValueReceiver< Tuple< Id, Data, String > && > &addValue)>
 
using GetDataCallbackType = Delegate< Result< Data >(const InternedId &id, const DataDictionary &dataEntry, GETDATAFLAGS flags)>
 
using DataDescriptionEntry = DataDictionary
 
using LanguageStringDataDescriptionDefinition = HashMap< Id, DataDescriptionDefinition >
 
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 Object * >(const Object *input)>
 
using StreamSubstitutionFunction = Delegate< Result< ObjectRef >(ObjectRef input, const Id &compressorId)>
 
template<typename T >
using Opaque = typename PrivateOpaque< T, void >::type
 
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 = ReferenceBase< FactoryFunctions< FACTORY, FactoryInterface::ReferenceFunctions< RefBaseFunctions< DirectRef< const FactoryInterface, StrongRefHandler, FACTORY > >> >>
 
using Group = void
 
using IdAndVersion = Tuple< Id, Id >
 
using UIntegerBase = UInt32
 
using NativeUInteger = UInteger< SIZEOF(Int) *8 >
 
using ExtractCallback = Delegate< Result< Bool >(const String &inputName, Url &outputName, IOATTRIBUTES &fileAttributes)>
 
using PIPEHANDLE = int
 
using UrlOrInputStream = UrlOrStream< InputStreamRef >
 
using UrlOrOutputStream = UrlOrStream< OutputStreamRef >
 
using TransformColorDelegate32 = Delegate< Color32(const Color32 &)>
 
using TransformColorDelegate64 = Delegate< Color64(const Color64 &)>
 
using TransformColorDelegate = TransformColorDelegate64
 
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 = SqMat3< Vector32 >
 
using SquareMatrix64 = SqMat3< Vector64 >
 
using SquareMatrix = SqMat3< Vector >
 
using Matrix32 = Mat3< Vector32 >
 
using Matrix64 = Mat3< Vector64 >
 
using Matrix = Mat3< Vector >
 
using SquareMatrix2d32 = SqMat2< Vector2d32 >
 
using SquareMatrix2d64 = SqMat2< Vector2d64 >
 
using SquareMatrix2d = SqMat2< Vector2d >
 
using Matrix2d32 = Mat2< Vector2d32 >
 
using Matrix2d64 = Mat2< Vector2d64 >
 
using Matrix2d = Mat2< Vector2d >
 
using SquareMatrix4d32 = SqMat4< Vector4d32 >
 
using SquareMatrix4d64 = SqMat4< Vector4d64 >
 
using SquareMatrix4d = SqMat4< Vector4d >
 
using MultiIndex64 = MultiIndex< UInt64 >
 
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 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 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 SystemFreeObject = void(*)(void *self)
 
using DestructorPointer = void(*)(void *)
 
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 ResultMem = ResultMemT< Bool >
 
template<typename... BASES>
using NonEmptyBases = typename maxon::details::NonEmptyBasesHelper< typename std::conditional< std::is_empty< BASES >::value, 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 >
 
using Vector32 = Vec3< Float32, 1 >
 
using Vector64 = Vec3< Float64, 1 >
 
using Vector = Vec3< Float, 1 >
 
using IntVector32 = Vec3< Int32, 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 StrongRefObserverCallback = Bool(*)(void *callbackData, const void *target)
 
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 DrawPointInt = DrawPoint< Int >
 
using DrawPointFloat = DrawPoint< Float >
 
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 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 *const
 
using MediaOutputSelectionHandler = Delegate< Result< SELECTIONHANDLERRESULT >(const MediaStreamRef &stream, const MediaStreamFormat &props)>
 
using MediaSessionProgressCallback = Delegate< void(const MediaSessionProgressRef &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 Quaternion32 = Quaternion< Float32 >
 
using Quaternion64 = Quaternion< Float64 >
 
template<typename T >
using enable_if_scalar = typename std::enable_if< std::is_scalar< T >::value, T >::type
 
template<typename T >
using enable_if_not_scalar = typename std::enable_if<!std::is_scalar< T >::value, T >::type
 
template<typename T >
using enable_if_float = typename std::enable_if< std::is_floating_point< T >::value, T >::type
 
template<typename T >
using enable_if_not_float = typename std::enable_if<!std::is_floating_point< T >::value, T >::type
 
template<typename T >
using enable_if_integral = typename std::enable_if< std::is_integral< T >::value, T >::type
 
template<typename T >
using enable_if_not_integral = typename std::enable_if<!std::is_integral< T >::value, T >::type
 
using SetContainerKey = UInt64
 
using GenericArrayView = ArrayViewBase< false, MAXON_FLEXIBLE_ARRAY_LENGTH >
 
using ConcatListViewRef = UniqueRef< ConcatListView >
 
using XformListViewRef = UniqueRef< XformListView >
 
using SCConversionFunction = Delegate< Result< Data >(const CString &val)>
 
using SCTypeConversion = HashMap< CString, SCConversionFunction >
 
using MySQLError = 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 GridAccessorBase = GridAccessorRef< Generic >
 
using DelegatePointObjectsPair = Pair< Delegate< Result< void >(void *, PointsToVolumeListRef &)>, BaseArray< void * > >
 
using DelegatePointObjectsPairList = BaseArray< DelegatePointObjectsPair >
 
using FunctionRegistration = Delegate< Result< void >(py::NativePyCFunctionWithKeywords func)>
 
using NativePyCFunctionTable = Tuple< const Char *, py::NativePyCFunctionWithKeywords >
 
using PyChar = Char
 

Enumerations

enum  OUTPUTLOCATION {
  BETA,
  C4D,
  NET,
  ALL
}
 
enum  MOVE_MODE {
  KEEP_SOURCE,
  DESTRUCT_SOURCE
}
 
enum  NO_MATCH_TYPE { VALUE }
 
enum  ENUM_DONT_INITIALIZE { VALUE }
 
enum  IN_PLACE_TYPE { VALUE }
 
enum  VALUEKIND : UInt64 {
  NONE,
  VOID_TYPE,
  GENERIC,
  GENERIC_ARITHMETIC,
  SCALAR,
  INTEGRAL,
  FLOATING_POINT,
  ENUM ,
  DATA,
  DATAPTR,
  NONVIRTUAL_INTERFACE,
  VIRTUAL_INTERFACE,
  REF_OR_POINTER,
  POINTER,
  STRONG_REFERENCE,
  COW_REFERENCE,
  UNIQUE_REFERENCE,
  ACOW_REFERENCE,
  LV_REFERENCE,
  RV_REFERENCE,
  TUPLE,
  NAMED_TUPLE,
  STRUCT,
  SIMD,
  BLOCK,
  STRIDED_BLOCK,
  ARRAY,
  BASEARRAY,
  BLOCKARRAY,
  RESULT,
  DELEGATE,
  FUNCTION,
  INDEXABLE,
  ABSTRACT_VIEW,
  ARRAY_VIEW,
  XFORM_VIEW,
  CONCAT_VIEW,
  VIEW_REF,
  ARRAY_CONTAINER,
  SET_CONTAINER,
  CONST_QUALIFIED,
  OPAQUE_QUALIFIED,
  SOURCE_LEVEL,
  INDIVIDUAL_MEMBERS,
  TIMESTAMPED,
  GENERIC_MEMBERS,
  ARRAY_VIEW_COW_REFS,
  DEEP_CONSTNESS,
  INT_SIZE_OR_LESS,
  ZERO_INITIALIZED,
  ORDERED,
  TRIVIALLY_CONSTRUCTIBLE,
  TRIVIALLY_DESTRUCTIBLE,
  TRIVIALLY_COPYABLE,
  TRIVIALLY_EQUATABLE,
  OBJECT_REF,
  ARRAY_CONTAINER_REF,
  SET_CONTAINER_REF,
  OWNS_TYPE_ARGUMENTS,
  COW_MASK,
  STRONG_MASK,
  PTR_MASK,
  VIEW_MASK,
  REFERENCE_MASK,
  ARRAY_CONTAINER_BASE_TEST,
  ARRAY_CONTAINER_REF_BASE_TEST,
  INDEXABLE_MASK,
  CONTAINER_MASK,
  CONTAINER_REF_MASK,
  ARITHMETIC_MASK,
  TUPLE_MASK,
  TUPLE_INHERIT_MASK,
  POINTER_FLAGS,
  QUALIFIER_MASK
}
 
enum  COLLECTION_KIND {
  NONE,
  ARRAY,
  SET,
  MAP
}
 
enum  SUBSYSTEM {
  UNDEFINED,
  CONSOLE,
  WINDOWS
}
 
enum  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
}
 
enum  APPLICATIONTYPE {
  OTHER,
  CPYTHON,
  CPYTHON3
}
 
enum  APPLICATIONMODE {
  DONTWAIT,
  KEEPRUNNING,
  SHUTDOWN
}
 
enum  BASEARRAYFLAGS {
  NONE,
  MOVEANDCOPYOBJECTS
}
 
enum  BLOCKARRAYFLAGS {
  NONE,
  MOVEANDCOPYOBJECTS,
  NOINSERTERASE,
  GROW_SLOWLY
}
 
enum  BURSTTRIE_SORT {
  NONE,
  LINEAR_SEARCH,
  BINARY_SEARCH
}
 
enum  BYTEORDER {
  BIG,
  LITTLE
}
 
enum  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,
  FIT_TO_SIZE,
  DEFAULT,
  POD_UNINITIALIZED
}
 
enum  CONFIGURATION_CATEGORY {
  REGULAR,
  DEVELOPMENT,
  MODULE,
  EXTENSION,
  IMPLEMENTATION,
  NONE
}
 
enum  CONFIGURATIONENTRY_ORIGIN {
  APPLICATION,
  CONFIGURATION,
  ENVIRONMENT,
  COMMANDLINE
}
 
enum  CONFIGURATIONENTRY_STATE {
  UNUSED,
  INVALIDARGUMENT,
  USED,
  OUTOFRANGE
}
 
enum  GETDATAFLAGS {
  NONE,
  INTENT_ENABLING,
  INTENT_ENABLING_ISCONNECTED
}
 
enum  DESCRIPTIONMESSAGECHECKFLAGS {
  NONE,
  ENABLED,
  VISIBLE,
  CHECKED,
  SORTSUBMENU
}
 
enum  LOADDESCRIPTIONMODE {
  COMPLETE,
  OVERWRITTEN
}
 
enum  PREPAREHELPERFLAGS {
  NONE,
  INITIALIZE_READ,
  INITIALIZE_WRITE,
  FINALIZE_READ,
  FINALIZE_WRITE,
  VALIDATE_STATE
}
 
enum  INNERMOST_MEMBER : Int32
 
enum  CONVERSION_FLAGS {
  NONE,
  IDENTITY,
  NARROWING,
  WIDENING_LOSSY,
  WIDENING_LOSSLESS,
  EXPANDING,
  REDUCING,
  WIDENING_MASK
}
 
enum  GET_DATATYPE_POLICY {
  NONE,
  GENERIC_FOR_UNKNOWN,
  ERROR_FOR_UNKNOWN,
  NO_DECAY,
  ALLOW_BASEARRAY,
  RESULT_FOR_UNKNOWN_MASK
}
 
enum  DATATYPEMODE {
  SMALLISPOD,
  SMALL,
  BIG
}
 
enum  DAYOFWEEK {
  MONDAY,
  TUESDAY,
  WEDNESDAY,
  THURSDAY,
  FRIDAY,
  SATURDAY,
  SUNDAY
}
 
enum  DST : Int16 {
  AUTOMATIC,
  NOTSET,
  SET
}
 
enum  JULIANDATE {
  STANDARD,
  REDUCED,
  MODIFIED,
  LEGACY,
  TRUNCATED,
  DUBLIN,
  LILIAN,
  RATEDIE,
  UNIXTIME,
  MARSSOL
}
 
enum  HARDWAREBREAKPOINTTYPE {
  CODE,
  READWRITE,
  WRITE
}
 
enum  HARDWAREBREAKPOINTSIZE {
  SIZE1,
  SIZE2,
  SIZE4,
  SIZE8
}
 
enum  FILEFORMAT_PRIORITY {
  SHIFT_ONE,
  SHIFT_TEN,
  FALLBACKFORMAT,
  GENERALFORMAT,
  NATIVEFORMAT
}
 
enum  HASHMAP_ENTRY_LAYOUT {
  KEY_VALUE,
  VALUE_KEY,
  VALUE
}
 
enum  ASSET_UPDATE_POLICY {
  NEVER,
  EXPLICIT,
  IMPLICIT
}
 
enum  IOARCHIVESTOREMETHOD {
  STORE,
  DEFLATE
}
 
enum  IOARCHIVEEXTRACTFLAGS {
  NONE,
  OVERWRITE_EXISTING_FILE
}
 
enum  IOBROWSEFLAGS {
  NONE,
  IS_DIRECTORY,
  IS_BUNDLE,
  IS_READONLY,
  IS_HIDDEN,
  SUPPORT_REVISIONS,
  IS_LINK,
  IS_ENCRYPTED,
  IS_DELETED,
  IS_INVISIBLE
}
 
enum  IOTIMEMODE {
  CREATED,
  MODIFIED,
  ACCESSED
}
 
enum  URLCOMPARE {
  DEFAULT,
  NORMALIZE,
  IONORMALIZE,
  LEGACY
}
 
enum  IODETECT {
  ERRORSTATE,
  NONEXISTENT,
  UNKNOWN,
  FILE,
  LINK,
  DIRECTORY
}
 
enum  OPENSTREAMFLAGS {
  NONE,
  WRITE_DONT_TRUNCATE,
  ALLOW_SHARED_READ_WRITE_ACCESS,
  SEEK_TO_END,
  FULL_DUPLEX
}
 
enum  NORMALIZEFLAGS {
  NONE,
  SCHEME_BASED,
  CASE,
  PATH_SEGMENT,
  UNICODE_DECOMPOSITION,
  UNDERLYING
}
 
enum  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  IOSHOWINOSFLAGS {
  NONE,
  SHOW_IN_EXPLORER,
  OPEN_IN_EXPLORER
}
 
enum  JOBGROUPFLAGS {
  DEFAULT,
  ENQUEUEING_THREAD_WAITS,
  FINALIZE_ON_WAIT,
  THREAD_AFFINITY
}
 
enum  STATICJOBGROUPFLAGS {
  DEFAULT,
  ENQUEUEING_THREAD_WAITS,
  THREAD_AFFINITY
}
 
enum  STATICJOBARRAYFLAGS {
  DEFAULT,
  INITIALIZE_LATER
}
 
enum  JOBQUEUETYPE {
  MAINTHREAD,
  NONE,
  LOWESTPRIORITY,
  LOWPRIORITY,
  NORMALPRIORITY,
  SERVICEIO,
  THREADLESS
}
 
enum  JOBQUEUEMODE {
  DEFAULT,
  SPIN_ON_IDLE,
  SLEEP_ON_IDLE,
  DETACH_THREADS,
  PSEUDO_THREADS
}
 
enum  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
}
 
enum  LEXERSYMBOLFLAGS {
  NONE,
  NO_NUMBER,
  ALLOWSTRINGS
}
 
enum  LEXERINITFLAGS {
  NONE,
  NEED_EOL,
  REWIND_WHEN_DONE,
  C4DSTRCOMPATIBILITY
}
 
enum  ROTATIONORDER {
  ZXYGLOBAL,
  ZYXGLOBAL,
  YXZGLOBAL,
  YZXGLOBAL,
  XZYGLOBAL,
  XYZGLOBAL,
  YXZLOCAL,
  XYZLOCAL,
  ZXYLOCAL,
  XZYLOCAL,
  YZXLOCAL,
  ZYXLOCAL
}
 
enum  MACHINESTATE {
  NONE,
  CONNECTION_ERROR,
  ADDED_MANUALLY,
  AVAILABLE_ZEROCONF,
  CONNECTED,
  ALL
}
 
enum  NULL_RETURN_REASON {
  NULLPTR,
  MAKE_WRITABLE_FAILED,
  UNRESOLVED,
  NULLIMPL
}
 
enum  NO_VALUE_TYPE { VALUE }
 
enum  PARALLELFORFLAGS {
  INITTHREADED_FINALIZETHREADED,
  INITTHREADED_FINALIZESYNC,
  INITSYNC_FINALIZETHREADED,
  INITSYNC_FINALIZESYNC,
  NOINIT_NOFINALIZE,
  INITTHREADEDWITHSYNC_FINALIZESYNC
}
 
enum  NETWORKPROTOCOLJSONFLAGS {
  NONE,
  HAS_NO_EOF
}
 
enum  BASESORTFLAGS {
  NONE,
  MOVEANDCOPYOBJECTS
}
 
enum  STRINGCONVERSION {
  NONE,
  ALLOW_MORE_CHARACTERS
}
 
enum  STRINGCOMPARISON {
  MEMORY,
  UNICODE_LETTERS,
  UNICODE_NUMBERS,
  CASEINSENSITIVE,
  CASEINSENSITIVE_NUMBERS
}
 
enum  EXECUTEPROGRAMFLAGS {
  NONE,
  CAPTURELOGFILE,
  DONT_DELETE_LOGFILE,
  START_ELEVATED,
  HIDE_APPLICATION
}
 
enum  EXECUTEPROGRAMCALLBACK {
  STARTED,
  RUNNING,
  FINISHED,
  KILLED,
  CLEANUP_OK,
  CLEANUP_FAILED
}
 
enum  WAIT_PROCESS_RESULT {
  FINISHED,
  RUNNING
}
 
enum  THREADPRIORITY : Int16 {
  NORMAL,
  ABOVE,
  BELOW,
  LOWEST
}
 
enum  WAITMODE {
  DEFAULT,
  RETURN_ON_CANCEL,
  PRIVATE_BLOCKING,
  EXTERNAL_ENQUEUE
}
 
enum  THREADTYPE {
  MAIN,
  WORKER,
  STANDALONE,
  ALIEN,
  ASSIMILATED
}
 
enum  TIMEFORMAT {
  SECONDS,
  FRAMES,
  SMPTE,
  SMPTE_DROPFRAMES
}
 
enum  NORMALIZATION {
  NFC,
  NFD,
  NKDC,
  NFKD,
  NFD_HFS
}
 
enum  BASE_DIMENSION {
  LENGTH,
  TIME,
  MASS,
  TEMPERATURE,
  AMOUNT_OF_SUBSTANCE,
  ELECTRIC_CURRENT,
  LUMINOUS_INTENSITY,
  ANGLE,
  SOLID_ANGLE,
  PRIVATE_COUNT
}
 
enum  GETBROWSEITERATORFLAGS {
  NONE,
  NOERRORONOPEN,
  RESOLVEPATHS
}
 
enum  URLFILECACHEFLAGS {
  NONE,
  FORCE_RELOAD
}
 
enum  COMPARERESULT {
  LESS,
  EQUAL,
  GREATER,
  INCOMPARABLE
}
 
enum  EQUALITY {
  SHALLOW,
  DEEP
}
 
enum  TARGETAUDIENCE {
  DEBUGGER,
  DEVELOPERS,
  USERS,
  ALL
}
 
enum  WRITEMETA {
  DEFAULT,
  WARNING,
  CRITICAL,
  NONEWLINE,
  UI_SYNC_DRAW
}
 
enum  OUTPUT {
  DIAGNOSTIC,
  WARNING,
  CRITICAL,
  NOLINEBREAK,
  HEADER
}
 
enum  ERROR_OK { VALUE }
 
enum  ERROR_FAILED { VALUE }
 
enum  ERROR_TYPE {
  OUT_OF_MEMORY,
  NULLPTR,
  ILLEGAL_ARGUMENT,
  ILLEGAL_STATE,
  NOT_IMPLEMENTED,
  UNRESOLVED,
  UNKNOWN
}
 
enum  COMMANDSTATE {
  DISABLED,
  ENABLED
}
 
enum  COMMANDRESULT {
  OK,
  SKIP,
  BREAK
}
 
enum  INTERACTIONTYPE {
  NONE,
  START,
  ITERATE,
  END,
  REALTIME
}
 
enum  BLOCK_CIPHER_MODE : UInt64 {
  ECB,
  CBC,
  PCBC,
  CFB,
  OFB,
  CTR,
  KEEP_STATE
}
 
enum  GRAPH_TYPE {
  CONTINUOS,
  SPARSE
}
 
enum  IMAGEHIERARCHY {
  TEXTURE,
  IMAGE,
  ALPHA,
  LAYER,
  MASK,
  DEEPIMAGEDATA,
  MAX_ELEMENTS
}
 
enum  COLORPROFILEINFO {
  DESCRIPTION,
  MANUFACTURER,
  MODEL,
  COPYRIGHT
}
 
enum  COLORCONVERSIONINTENT {
  PERCEPTUAL,
  RELATIVE_COLORIMETRIC,
  SATURATION,
  ABSOLUTE_COLORIMETRIC
}
 
enum  COLORCONVERSIONFLAGS {
  NONE,
  BLACKPOINTCOMPENSATION
}
 
enum  CONVERTPIXELFLAGS {
  NONE,
  FORCECOLORPROFILECONVERSION
}
 
enum  GETPIXELHANDLERFLAGS {
  NONE,
  FORCECOLORPROFILECONVERSION,
  DEEPIMAGE
}
 
enum  GETPIXELFLAGS {
  NONE,
  DEEPIMAGE
}
 
enum  SETPIXELHANDLERFLAGS {
  NONE,
  FORCECOLORPROFILECONVERSION,
  DEEPIMAGE
}
 
enum  SETPIXELFLAGS {
  NONE,
  DEEPIMAGE
}
 
enum  LAYERSETMODE {
  LAYERS,
  LAYERMASKS,
  ALPHAS,
  LAYERALPHA,
  DISABLED
}
 
enum  MEDIAFORMATTYPE {
  UNDEFINED,
  IMAGE,
  ALPHA,
  LAYERFOLDER,
  LAYER,
  LAYERADJUSTMENT,
  LAYERMASK,
  MIPMAP,
  DEEPIMAGEDATA
}
 
enum  MEDIAALPHATYPE {
  UNDEFINED,
  PREMULTIPLIED,
  STRAIGHT
}
 
enum  RLACHANNELS {
  Z,
  MATERIALID,
  NODE_ID,
  UV,
  NORMAL,
  REALPIX,
  COVERAGE,
  BG,
  NODE_RENDER_ID,
  COLOR,
  TRANSP,
  VELOC,
  WEIGHT,
  MASK,
  MAXCOUNT
}
 
enum  RLAFLAGS {
  NONE,
  Z,
  MATERIALID,
  OBJECTBUFFER,
  UV,
  NORMAL,
  ORIGCOLOR,
  COVERAGE,
  BG,
  OBJECTID,
  COLOR,
  TRANSPARENCY,
  SUBPIXEL_WEIGHT,
  SUBPIXEL_MASK
}
 
enum  SELECTIONHANDLERRESULT {
  NONE,
  STRUCTURE,
  CONTENT_FLAG,
  STRUCTURE_WITH_CONTENT,
  ALL
}
 
enum  MEDIASESSIONFLAGS {
  NONE,
  RUNONLYANALYZE,
  FORCELOAD
}
 
enum  ANIMBLENDSTATE {
  NONE,
  STARTED,
  RUNNING,
  FINISHED,
  CANCELED
}
 
enum  FFT_FLAGS {
  NONE,
  CALC_INVERSE,
  SUPPRESS_PADDING
}
 
enum  FFT_SUPPORT {
  NONE,
  TRANSFORM_1D,
  TRANSFORM_2D,
  ALWAYS_PADDING
}
 
enum  GRADIENT_INTERPOLATION_TYPE {
  CUBICKNOT,
  SMOOTHKNOT,
  LINEARKNOT,
  NONE,
  EXP_UP,
  EXP_DOWN,
  BLEND
}
 
enum  NURBSCURVE_CONTINUITY {
  OPEN,
  CLOSED,
  PERIODIC
}
 
enum  NURBSCURVE_KNOTMODE {
  CLAMPED_UNIFORM,
  CLAMPED_CHORDAL,
  CLAMPED_CENTRIPETAL,
  UNCLAMPED_UNIFORM
}
 
enum  PRIMITIVETYPE {
  NONE,
  POINT,
  EDGE,
  POLYGON
}
 
enum  METRICUNIT {
  NONE,
  KM,
  M,
  CM,
  MM,
  UM,
  NM,
  MILE,
  YARD,
  FEET,
  INCH
}
 
enum  ANGLEUNIT {
  DEGREE,
  RADIANS
}
 
enum  IOFORMAT {
  DEFAULT,
  BINARY,
  BINARY_COMPRESSED,
  JSON,
  XML,
  JSON_STABLE
}
 
enum  PROFILER_POINT_TYPE {
  NONE,
  METHOD_ENTER,
  METHOD_LEAVE,
  SCOPE_ENTER,
  SCOPE_LEAVE,
  DELTA
}
 
enum  PROFILER_STATE {
  DISABLED,
  ENABLED_METHOD_SCOPE,
  ENABLED_ALL
}
 
enum  PROFILER_CLOCK_MODE {
  NORMAL,
  SIMULATED
}
 
enum  REGPARSEMODE {
  MATCH,
  CONTAINS,
  STARTS,
  ENDS
}
 
enum  HTTPCODE {
  CLOSED,
  FINISHED,
  CALL_NEXT_HANDLER,
  OK,
  POST,
  MOVED,
  SYNTAX,
  AUTH,
  ACCESS,
  NOTFOUND,
  INTERNAL,
  UNKNOWN
}
 
enum  SOCKETMODE {
  READ,
  WRITE,
  LISTEN,
  CONNECT
}
 
enum  CONNECTIONMODE {
  UNDEFINED,
  SEND,
  READ
}
 
enum  CONNECTIONTYPE {
  LISTENER,
  INCOMING,
  OUTGOING
}
 
enum  PROTOCOL {
  UNSPEC,
  IPV4,
  IPV6
}
 
enum  WILDCARD_IPV4_ADDRESS_TYPE { VALUE }
 
enum  WILDCARD_IPV6_ADDRESS_TYPE { VALUE }
 
enum  SSLSOCKETTYPE {
  CLIENTCONNECTION,
  SERVERCONNECTION
}
 
enum  SSLPROTOCOLVERSION {
  TLS1,
  TLS11,
  TLS12,
  SSL3,
  SSL2,
  SSL23
}
 
enum  SSLCERTREQUIREMENTS {
  NONE,
  OPTIONAL,
  REQUIRED,
  MODE,
  VERIFY_AUTHORITY
}
 
enum  SSLFILETYPE {
  ASN1,
  PEM
}
 
enum  OAUTHSIGNATUREMETHOD {
  NONE,
  PLAINTEXT,
  HMAC_SHA1
}
 
enum  OAUTHHTTPMETHOD {
  NONE,
  GET,
  POST
}
 
enum  MEDIA {
  UNKNOWN,
  TEXT,
  IMAGE,
  AUDIO,
  VIDEO,
  APP,
  MULTI
}
 
enum  MEDIASUB {
  UNKNOWN,
  HTML,
  HTML_PLAIN,
  GIF,
  JPEG,
  PNG,
  TIFF,
  MPEG,
  QUICKTIME,
  X_MSVIDEO,
  RTF,
  MAC_BINHEX40,
  X_STUFFIT,
  ZIP,
  OCTET_STREAM,
  POSTSCRIPT,
  PDF
}
 
enum  SMTPRECEIVERFIELD : UChar {
  TO,
  CC,
  BCC
}
 
enum  HTTPREQUESTTYPE {
  UNKNOWN,
  GET,
  POST
}
 
enum  WEBSOCKETSTATE {
  NOT_CONNECTED,
  CONNECTED,
  CLOSED,
  ERROR
}
 
enum  WEBSOCKETTYPE {
  TEXT,
  BINARY,
  CLOSE
}
 
enum  WEBSOCKET_OPCODE : UChar {
  CONTINUE,
  TEXT,
  DATA,
  CLOSE,
  PING,
  PONG,
  ILLEGAL
}
 
enum  ZEROCONFACTION {
  NONE,
  RESOLVE,
  MONITOR
}
 
enum  ZEROCONFMACHINESTATE {
  ONLINE,
  OFFLINE,
  REMOVED,
  UPDATE
}
 
enum  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  VOLUMESAMPLER {
  NEAREST,
  LINEAR,
  QUADRATIC
}
 
enum  ITERATORTYPE {
  ALL,
  ON,
  OFF
}
 
enum  SDFFILTERTYPE {
  NONE,
  GAUSSIAN,
  DILATE,
  ERODE,
  MEANVALUE,
  MEDIANVALUE,
  MEANCURVATURE,
  LAPLACIANFLOW,
  RENORMALIZE,
  OPEN,
  CLOSE,
  TRACK,
  RESIZE
}
 
enum  FILTERTYPE {
  NONE,
  GAUSSIAN,
  MEANVALUE,
  MEDIANVALUE,
  OFFSET,
  REMAP,
  CURVEREMAP
}
 
enum  FILTERACCURACY {
  NONE,
  FIRST,
  SECOND,
  THIRD,
  WENO5,
  HJWENO5
}
 
enum  RESAMPLEINTERPOLATIONTYPE {
  NONE,
  NEAREST,
  LINEAR,
  QUADRATIC
}
 
enum  OWNERSHIP {
  NORMAL,
  CALLER,
  CALLEE,
  CALLER_BUT_COPY
}
 
enum  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  CONTAINS : int {
  _FOUND,
  _NOTFOUND,
  _ERROR
}
 
enum  VMSETTINGS {
  MOVE_ERRORS_TO_RESULT,
  USE_AUTO_GIL
}
 
enum  VMINITSETTINGS {
  CPYTHON_ADDITIONAL_SYS_PATH,
  CPYTHON_INTERPRETERFLAGS,
  CPYTHON_SUBINTERPRETER,
  PYPY_EXECUTABLE
}
 
enum  ERRORHANDLING {
  PRINT,
  CLEAR,
  REDIRECT
}
 
enum  DEFAULTRUNTIME {
  NONE,
  SYSTEM_27,
  SYSTEM_36,
  DEBUG_27_VS2008,
  DEBUG_27_VS2013,
  DEBUG_27_VS2015,
  DEBUG_36_VS2015,
  RELEASE_27_VS2008,
  RELEASE_27_VS2015,
  RELEASE_36_VS2015,
  DEBUG_27,
  RELEASE_27,
  DEBUG_36,
  RELEASE_36,
  DEFAULT_27,
  DEFAULT_36,
  DEFAULT
}
 

Functions

Result< BaseArray< Url > > BrowserReceiveUrls (void *dat)
 
enum maxon::OUTPUTLOCATION MAXON_ENUM_FLAGS (OUTPUTLOCATION)
 
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 Construct (ITERATOR first, SENTINEL sentinel, const ARGS &... args) -> ITERATOR
 
template<typename ITERABLE , typename ... ARGS, typename = typename std::enable_if<IsIterable<ITERABLE>::value>::type>
auto Construct (ITERABLE &&iterable, const ARGS &... args) -> decltype(begin(iterable))
 
template<typename ITERATOR , typename SENTINEL , typename = typename std::enable_if<!IsIterable<ITERATOR>::value>::type>
auto Destruct (ITERATOR first, SENTINEL sentinel) -> ITERATOR
 
template<typename ITERABLE , typename = typename std::enable_if<IsIterable<ITERABLE>::value>::type>
auto Destruct (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 ITERATOR , typename SENTINEL , typename T >
auto Fill (ITERATOR first, SENTINEL sentinel, const T &value) -> 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 ITERATOR >
auto Reverse (ITERATOR first, ITERATOR last) -> ITERATOR
 
template<typename ITERATOR , typename SENTINEL >
auto Reverse (ITERATOR first, SENTINEL sentinel) -> ITERATOR
 
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 ITERATOR , typename SENTINEL , typename PREDICATE >
auto RemoveIf (ITERATOR first, SENTINEL sentinel, PREDICATE pred) -> ITERATOR
 
template<typename ITERABLE , typename PREDICATE >
auto RemoveIf (ITERABLE &&iterable, PREDICATE pred) -> decltype(begin(iterable))
 
template<typename ITERATOR , typename SENTINEL , typename T >
auto Replace (ITERATOR first, SENTINEL sentinel, const T &oldValue, const T &newValue) -> ITERATOR
 
template<typename ITERABLE , typename T >
auto Replace (ITERABLE &&iterable, const T &oldValue, const T &newValue) -> decltype(begin(iterable))
 
template<typename ITERATOR , typename SENTINEL , typename PREDICATE , typename T >
auto ReplaceIf (ITERATOR first, SENTINEL sentinel, PREDICATE pred, const T &newValue) -> ITERATOR
 
template<typename ITERABLE , typename PREDICATE , typename T >
auto ReplaceIf (ITERABLE &&iterable, PREDICATE pred, const T &newValue) -> decltype(begin(iterable))
 
template<typename ITERATOR , typename SENTINEL , typename V , typename BINARYOP >
V Fold (ITERATOR first, SENTINEL sentinel, V initialValue, BINARYOP op)
 
template<typename ITERABLE , typename V , typename BINARYOP >
V Fold (const ITERABLE &iterable, const V &intitialValue, BINARYOP op)
 
template<typename ITERATOR , typename SENTINEL >
auto MinElement (ITERATOR first, SENTINEL sentinel) -> Optional< ITERATOR >
 
template<typename ITERATOR , typename SENTINEL , typename COMPARE >
auto MinElement (ITERATOR first, SENTINEL sentinel, COMPARE comp) -> Optional< ITERATOR >
 
template<typename ITERABLE >
auto MinElement (ITERABLE &&iterable) -> Optional< decltype(begin(iterable))>
 
template<typename ITERABLE , typename COMPARE >
auto MinElement (ITERABLE &&iterable, COMPARE comp) -> Optional< decltype(begin(iterable))>
 
template<typename ITERATOR , typename SENTINEL >
auto MaxElement (ITERATOR first, SENTINEL sentinel) -> Optional< ITERATOR >
 
template<typename ITERATOR , typename SENTINEL , typename COMPARE >
auto MaxElement (ITERATOR first, SENTINEL sentinel, COMPARE comp) -> Optional< ITERATOR >
 
template<typename ITERABLE >
auto MaxElement (ITERABLE &&iterable) -> Optional< decltype(begin(iterable))>
 
template<typename ITERABLE , typename COMPARE >
auto MaxElement (ITERABLE &&iterable, COMPARE comp) -> Optional< decltype(begin(iterable))>
 
template<typename ITERATOR >
Int GetSequenceLength (ITERATOR first, ITERATOR last)
 
template<typename ITERATOR , typename SENTINEL >
Int GetSequenceLength (ITERATOR first, SENTINEL sentinel)
 
template<typename ITERABLE >
Int GetSequenceLength (const ITERABLE &iterable)
 
enum maxon::NO_MATCH_TYPE MAXON_ENUM_LIST (NO_MATCH_TYPE)
 
template<typename 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 >
 
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)
 
constexpr UInt UIntPow (UInt x, Int exp)
 
constexpr UInt PrivateGetHashCode (const char *str, Int len)
 
constexpr UInt PrivateGetHashCode (const Utf32Char *str, Int len)
 
const String & StringInterface_GetAndCacheConstString (const wchar_t *str, Int len)
 
const String & StringInterface_GetAndCacheConstString (const Char *str, Int len, Int isUtf8)
 
constexpr Bool PrivateIsUtf8 (const char *str, Int len)
 
const String & operator"" _s (const char *str, std::size_t cnt)
 
const String & operator"" _s (const wchar_t *str, std::size_t cnt)
 
template<typename T >
String GlobalToString (const T &object, const FormatStatement *formatStatement, Bool checkDataType=true)
 
enum maxon::ENUM_DONT_INITIALIZE MAXON_ENUM_LIST (ENUM_DONT_INITIALIZE)
 
enum maxon::IN_PLACE_TYPE MAXON_ENUM_LIST (IN_PLACE_TYPE)
 
template<typename T >
std::enable_if<(sizeof(T) > 0), std::true_type >::type IsCompleteHelper (T *)
 
std::false_type IsCompleteHelper (...)
 
template<typename T >
const T & GetZeroRef ()
 
template<typename T >
const T & GetPtrSizedZeroRef ()
 
template<typename T >
T NullValue ()
 
Bool MaxonStart (int argc, char **argv, InitMTable initSystemTable)
 
Bool MaxonEnd ()
 
 Helper (OverloadRank2, T &obj MAXON_MAKE_LIST(PRIVATE_MAXON_DETECT_MEMBER_HELPER1,,,,)) -> decltype(obj. GetMemorySize(MAXON_MAKE_COMMA_LIST(PRIVATE_MAXON_DETECT_MEMBER_HELPER2,,,)))
 
 Helper (OverloadRank1, T &obj MAXON_MAKE_LIST(PRIVATE_MAXON_DETECT_MEMBER_HELPER1,,,,)) -> decltype(GetMemorySize(obj MAXON_MAKE_LIST(PRIVATE_MAXON_DETECT_MEMBER_HELPER3,,,,)))
 
 Helper (T &obj MAXON_MAKE_LIST(PRIVATE_MAXON_DETECT_MEMBER_HELPER1,,,,)) -> decltype(MAXON_CONCAT(GetMemorySize, Helper)(((maxon::OverloadRankMax) nullptr), obj MAXON_MAKE_LIST(PRIVATE_MAXON_DETECT_MEMBER_HELPER3,,,,)))
 
template<typename X >
T & __attribute__ ((always_inline)) void UseVariable(X &&var)
 
enum maxon::VALUEKIND UInt64 MAXON_ENUM_FLAGS (VALUEKIND, "net.maxon.datatype.enum.valuekind", EARLY)
 
enum maxon::COLLECTION_KIND MAXON_ENUM_LIST (COLLECTION_KIND)
 
template<typename T >
std::false_type TestForCopyFromFunction (OverloadRank0)
 
template<typename T >
 __attribute__ ((always_inline)) Result< void > NewCopy(T &dst
 
template<typename T >
 __attribute__ ((always_inline)) ResultOk< T > NewCopy(T &&src)
 
template<typename T , typename U >
 __attribute__ ((always_inline)) Result< void > AssignCopyConvert(T &dst
 
template<typename T >
void Destruct (const T *object)
 
enum maxon::SUBSYSTEM MAXON_ENUM_LIST (SUBSYSTEM, "net.maxon.datatype.enum.subsystem")
 
enum maxon::APPLICATION_URLTYPE MAXON_ENUM_LIST (APPLICATION_URLTYPE, "net.maxon.datatype.enum.application_urltype")
 
enum maxon::APPLICATIONTYPE MAXON_ENUM_LIST (APPLICATIONTYPE, "net.maxon.datatype.enum.applicationtype")
 
enum maxon::APPLICATIONMODE MAXON_ENUM_LIST (APPLICATIONMODE, "net.maxon.datatype.enum.applicationmode")
 
template<GET_DATATYPE_POLICY POLICY, typename T >
Result< const DataType * > PrivateGetDataType (ArrayInterface< T > *, OverloadRank0)
 
template<typename ARRAY >
 MAXON_IMPLEMENTATION_REGISTER_SIMPLE (ArrayImpl< ARRAY >, typename)
 
template<typename T >
const ArrayInterface< T > * ToArrayPtr (const ArrayInterface< T > &array)
 
template<typename T >
WritableArrayInterface< T > * ToWritableArrayPtr (WritableArrayInterface< T > &array)
 
enum maxon::BASEARRAYFLAGS MAXON_ENUM_FLAGS (BASEARRAYFLAGS)
 
template<typename T >
T * PrivateInitCopy (void *ptr, const T &src)
 
Int Ctz32 (Int32 x)
 
Int Ctz64 (Int64 x)
 
Int Clz32 (Int32 x)
 
Int Clz64 (Int64 x)
 
template<typename T >
Int Clz (T x)
 
template<typename T >
Int Ctz (T x)
 
template<typename T , Int N>
Block< T > ToBlock (T(&array)[N])
 
template<typename T >
Block< typename maxon::details::BlockType< T >::type > ToBlock (T *ptr, Int size)
 
template<typename T >
Block< T > ToSingletonBlock (T &value)
 
template<typename T >
Block< const T > ToSingletonBlock (const T &value)
 
template<typename T >
StridedBlock< typename maxon::details::BlockType< T >::type > ToBlock (T *ptr, Int size, Int stride)
 
Block< const Char > CharToBlock (const Char *str)
 
Block< const UChar > CharToBlock (const UChar *str)
 
template<Int N>
Block< const Char > CharToBlock (const Char(&str)[N])
 
template<Int N>
Block< const UChar > CharToBlock (const UChar(&str)[N])
 
template<Int N>
Block< const Utf32Char > CharToBlock (const Utf32Char(&str)[N])
 
enum maxon::BLOCKARRAYFLAGS MAXON_ENUM_FLAGS (BLOCKARRAYFLAGS)
 
enum maxon::BURSTTRIE_SORT MAXON_ENUM_LIST (BURSTTRIE_SORT)
 
enum maxon::BYTEORDER MAXON_ENUM_LIST (BYTEORDER)
 
MAXON_ATTRIBUTE_FORCE_INLINE UInt16 SwapByteOrder (UInt16 data)
 
MAXON_ATTRIBUTE_FORCE_INLINE Int16 SwapByteOrder (Int16 data)
 
MAXON_ATTRIBUTE_FORCE_INLINE UInt32 SwapByteOrder (UInt32 data)
 
MAXON_ATTRIBUTE_FORCE_INLINE Int32 SwapByteOrder (Int32 data)
 
MAXON_ATTRIBUTE_FORCE_INLINE UInt64 SwapByteOrder (UInt64 data)
 
MAXON_ATTRIBUTE_FORCE_INLINE Int64 SwapByteOrder (Int64 data)
 
MAXON_ATTRIBUTE_FORCE_INLINE UInt16 SwapUInt16 (UInt16 data)
 
MAXON_ATTRIBUTE_FORCE_INLINE Int16 SwapInt16 (Int16 data)
 
MAXON_ATTRIBUTE_FORCE_INLINE UInt32 SwapUInt32 (UInt32 data)
 
MAXON_ATTRIBUTE_FORCE_INLINE Int32 SwapInt32 (Int32 data)
 
MAXON_ATTRIBUTE_FORCE_INLINE UInt64 SwapUInt64 (UInt64 data)
 
MAXON_ATTRIBUTE_FORCE_INLINE Int64 SwapInt64 (Int64 data)
 
MAXON_ATTRIBUTE_FORCE_INLINE void SwapUInt16 (UInt16 *addr, Int count=1)
 
MAXON_ATTRIBUTE_FORCE_INLINE void SwapInt16 (Int16 *addr, Int count=1)
 
MAXON_ATTRIBUTE_FORCE_INLINE void SwapUInt32 (UInt32 *addr, Int count=1)
 
MAXON_ATTRIBUTE_FORCE_INLINE void SwapInt32 (Int32 *addr, Int count=1)
 
MAXON_ATTRIBUTE_FORCE_INLINE void SwapUInt64 (UInt64 *addr, Int count=1)
 
MAXON_ATTRIBUTE_FORCE_INLINE void SwapInt64 (Int64 *addr, Int count=1)
 
template<BYTEORDER order>
MAXON_ATTRIBUTE_FORCE_INLINE void ByteOrder_UInt16 (UInt16 *addr, Int count=1)
 
template<BYTEORDER order>
MAXON_ATTRIBUTE_FORCE_INLINE void ByteOrder_Int16 (Int16 *addr, Int count=1)
 
template<BYTEORDER order>
MAXON_ATTRIBUTE_FORCE_INLINE void ByteOrder_UInt32 (UInt32 *addr, Int count=1)
 
template<BYTEORDER order>
MAXON_ATTRIBUTE_FORCE_INLINE void ByteOrder_Int32 (Int32 *addr, Int count=1)
 
template<BYTEORDER order>
MAXON_ATTRIBUTE_FORCE_INLINE void ByteOrder_UInt64 (UInt64 *addr, Int count=1)
 
template<BYTEORDER order>
MAXON_ATTRIBUTE_FORCE_INLINE void ByteOrder_Int64 (Int64 *addr, Int count=1)
 
 MAXON_DATATYPE (BytesValue, "net.maxon.datatype.bytesvalue")
 
template<typename C >
Int PrivateGetCount (const C &collection, OverloadRank0)
 
template<typename T , Int N>
Int PrivateGetCount (T(&array)[N], OverloadRank1)
 
template<typename C >
SFINAEHelper< Int, typename C::IsCollection >::type PrivateGetCount (const C &collection, OverloadRank2)
 
template<typename ITERABLE >
Int GetCount (const ITERABLE &iterable)
 
template<typename SET , typename KEY >
MAXON_ATTRIBUTE_FORCE_INLINE Bool PrivateContains (const SET &set, const KEY &key, OverloadRank0)
 
template<typename T , Int N, typename KEY >
Bool PrivateContains (T(&array)[N], const KEY &key, OverloadRank1)
 
template<typename SET , typename KEY >
MAXON_ATTRIBUTE_FORCE_INLINE auto PrivateContains (const SET &set, const KEY &key, OverloadRank1) -> decltype(set.Contains(key))
 
template<typename SET , typename KEY >
MAXON_ATTRIBUTE_FORCE_INLINE SFINAEHelper< Bool, typename SET::IsCollection >::type PrivateContains (const SET &set, const KEY &key, OverloadRank2)
 
template<typename PREDICATE , typename KEY >
MAXON_ATTRIBUTE_FORCE_INLINE Bool Contains (const PREDICATE &predicate, const KEY &key)
 
template<typename COMPARE , typename T1 , typename T2 >
MAXON_ATTRIBUTE_FORCE_INLINE Bool PrivateIsEqual (COMPARE &&cmp, const T1 &a, const T2 &b, OverloadRank0)
 
template<typename COMPARE , typename T1 , typename T2 >
MAXON_ATTRIBUTE_FORCE_INLINE auto PrivateIsEqual (COMPARE &&cmp, const T1 &a, const T2 &b, OverloadRank1) -> decltype(cmp.IsEqual(a, b))
 
template<typename PREDICATE , typename T1 , typename T2 >
MAXON_ATTRIBUTE_FORCE_INLINE Bool IsEqual (PREDICATE &&predicate, const T1 &a, const T2 &b)
 
 MAXON_MEMBERTYPE_DETECTOR (IsCollection, IsCollection, std::false_type)
 
enum maxon::COLLECTION_RESIZE_FLAGS MAXON_ENUM_FLAGS (COLLECTION_RESIZE_FLAGS, "net.maxon.datatype.enum.collection_resize_flags", EARLY)
 
template<typename COLLECTION , typename T >
std::conditional<!std::is_reference< COLLECTION >::value &&(GetCollectionKind< COLLECTION >::value !=COLLECTION_KIND::NONE), T &&, T & >::type ValueForward (T &x)
 
template<typename COLLECTION , typename T , Bool STRIDED>
const Block< T, STRIDED, !std::is_reference< COLLECTION >::value &&(GetCollectionKind< COLLECTION >::value !=COLLECTION_KIND::NONE)> & BlockForward (const Block< T, STRIDED > &block)
 
template<typename COLLECTION >
COLLECTION && PrivateGetMap (COLLECTION &&c, OverloadRank0)
 
template<typename COLLECTION >
Substitute< COLLECTION &&, typename std::remove_reference< COLLECTION >::type::MapType >::type PrivateGetMap (COLLECTION &&c, OverloadRank1)
 
enum maxon::CONFIGURATION_CATEGORY MAXON_ENUM_LIST (CONFIGURATION_CATEGORY)
 
enum maxon::CONFIGURATIONENTRY_ORIGIN MAXON_ENUM_LIST (CONFIGURATIONENTRY_ORIGIN)
 
enum maxon::CONFIGURATIONENTRY_STATE MAXON_ENUM_LIST (CONFIGURATIONENTRY_STATE)
 
 MAXON_DEPENDENCY (configuration)
 
 MAXON_DEPENDENCY (cpuidinit)
 
template<typename T1 , typename T2 >
MAXON_ATTRIBUTE_FORCE_INLINE bool operator== (const CustomSTLAllocator< T1 > &, const CustomSTLAllocator< T2 > &) noexcept
 
template<typename T1 , typename T2 >
MAXON_ATTRIBUTE_FORCE_INLINE bool operator!= (const CustomSTLAllocator< T1 > &, const CustomSTLAllocator< T2 > &) noexcept
 
 MAXON_REGISTRY (CString, DataTypeCppIdentifiers, "net.maxon.registry.datatypecppidentifiers")
 
 MAXON_DATATYPE (LanguageStringDataDescription, "net.maxon.datatype.languagestringdatadescription")
 
 MAXON_DATATYPE (VariadicIdsElement, "net.maxon.datatype.variadicidselement")
 
template<typename T >
Result< void > AddResourceDefault (DataDictionary &props, const T &t, OverloadRank0)
 
template<typename T >
SFINAEHelper< Result< void >, typename T::HasDefault >::type AddResourceDefault (DataDictionary &props, const T &t, OverloadRank1)
 
template<typename TYPE >
Result< BaseArray< Tuple< Id, Data > > > BlockToEnumArray (const Block< TYPE > &enumBlock)
 
template<typename T >
Result< void > AddResourceProperty (DataDescription &description, const T &t, const Delegate< Result< void >(DataDictionary &props)> &addProps=nullptr)
 
template<typename T >
Result< void > EraseResourceProperty (DataDescription &description, const T &t)
 
 MAXON_DATATYPE (ProcessEnumListDelegate, "net.maxon.datatype.processenumlistdelegate")
 
 MAXON_REGISTRY (ProcessEnumListDelegate, ProcessEnumListDelegates, "net.maxon.datadescription.registry.processenumlist")
 
enum maxon::GETDATAFLAGS MAXON_ENUM_FLAGS (GETDATAFLAGS)
 
 MAXON_DECLARATION (Class< DataDescriptionDefinition >, DataDescriptionDefinitionClass, "net.maxon.class.datadescriptiondefinition")
 
 MAXON_DATATYPE (LanguageStringDataDescriptionDefinition, "net.maxon.datatype.languagestringdatadescriptiondefinition")
 
enum maxon::DESCRIPTIONMESSAGECHECKFLAGS MAXON_ENUM_FLAGS (DESCRIPTIONMESSAGECHECKFLAGS)
 
 MAXON_DATATYPE (DescriptionMessageCall, "net.maxon.datatype.descriptionmessagecall")
 
enum maxon::LOADDESCRIPTIONMODE MAXON_ENUM_LIST (LOADDESCRIPTIONMODE)
 
 MAXON_DECLARATION (Class< DataDescriptionObjectRef >, DataDescriptionObjectClass, "net.maxon.class.datadescriptionobject")
 
Result< void > MergeDataDictionaries (DataDictionary &base, const DataDictionary &other, Bool mergeSubContainers)
 
Result< Data > GetDataDescriptionValueI (const Id &databaseScope, const InternedId &attributeData, const ConstDataPtr &keyPtr)
 
template<typename ATTRIBUTETYPE , typename KEY >
static Result< typename IsFidClass< ATTRIBUTETYPE >::type > GetDataDescriptionValue (ATTRIBUTETYPE &&attribute, KEY &&key)
 
template<typename ATTRIBUTETYPE >
static Result< typename IsFidClass< ATTRIBUTETYPE >::type > GetDataDescriptionValue2 (ATTRIBUTETYPE &&attribute, const ConstDataPtr &key)
 
template<typename ATTRIBUTETYPE , typename KEY >
static Result< typename IsFidClass< KEY >::type > GetDataDescriptionValueFromKey (ATTRIBUTETYPE &&attribute, KEY &&key)
 
template<typename KEY >
IsFidClass< KEY >::type GetDefaultFromFidIfAvailable (KEY &&key, OverloadRank0)
 
template<typename KEY >
SFINAEHelper< typename IsFidClass< KEY >::type, decltype(std::remove_reference< KEY >::type::DEFAULTVALUE)>::type GetDefaultFromFidIfAvailable (KEY &&key, OverloadRank2)
 
ConstDataPtr GetDefaultValueKey ()
 
template<typename SRCCLASS , typename PROPSRCTYPE , typename DSTCLASS , typename PROPDSTTYPE >
Result< void > TransferPropertyIfAvailable (const SRCCLASS &src, PROPSRCTYPE &&srcType, DSTCLASS &dst, PROPDSTTYPE &&dstType)
 
 MAXON_DECLARATION (Class< DataDictionaryObjectRef >, DataDictionaryObjectEmptyClass, "net.maxon.class.datadictionaryobjectempty")
 
 MAXON_DECLARATION (Class< DataDictionaryObjectRef >, DataDictionaryObjectClass, "net.maxon.class.datadictionaryobject")
 
 MAXON_DECLARATION (Class< DataDictionaryObjectRef >, DataDictionaryObjectLockedClass, "net.maxon.class.datadictionaryobjectlocked")
 
 MAXON_DECLARATION (Class< DataDictionaryObjectRef >, DataDictionaryObjectSyncedClass, "net.maxon.class.datadictionaryobjectsynced")
 
 MAXON_DECLARATION (Class< DataDictionaryReferenceObjectRef >, DataDictionaryObjectReferenceClass, "net.maxon.class.datadictionaryobjectreference")
 
Result< DataDictionaryObjectRef > CreateDataDictionaryReferenceObject (DataDictionary *reference)
 
Result< DataDictionaryObjectRef > CreateDataDictionaryReferenceObject (const DataDictionary *reference)
 
Result< DataDictionary > GetDataDictionaryFromDataDictionaryObjectRef (const DataDictionaryObjectRef &ref)
 
 MAXON_REGISTRY (DataFormatReaderFactory, DataFormatReaderFactories, "net.maxon.registry.dataformatreaderfactories")
 
 MAXON_REGISTRY (DataFormatWriterFactory, DataFormatWriterFactories, "net.maxon.registry.dataformatwriterfactories")
 
 MAXON_DECLARATION (Class< DataFormatWriterRef >, DataFormatWriterBinaryClass, "net.maxon.class.dataformatwriterbinary")
 
 MAXON_DECLARATION (Class< DataFormatWriterRef >, DataFormatWriterJsonClass, "net.maxon.class.dataformatwriterjson")
 
 MAXON_DECLARATION (Class< DataFormatWriterRef >, DataFormatWriterXmlClass, "net.maxon.class.dataformatwriterxml")
 
 MAXON_DECLARATION (Class< DataFormatReaderRef >, DataFormatReaderBinaryClass, "net.maxon.class.dataformatreaderbinary")
 
 MAXON_DECLARATION (Class< DataFormatReaderRef >, DataFormatReaderJsonClass, "net.maxon.class.dataformatreaderjson")
 
 MAXON_DECLARATION (Class< DataFormatReaderRef >, DataFormatReaderXmlClass, "net.maxon.class.dataformatreaderxml")
 
 MAXON_DATATYPE_SCALAR (IDENT_VOID, "net.maxon.ident_void")
 
template<typename T >
ResultPtr< void > CreateHelper ()
 
template<typename T >
void DeleteHelper (void *helper)
 
template<typename MAINCLASS , typename HELPERCLASS >
Result< void > ReadHelper (DataSerializeInterface *ds, void *classPtr, void *helperPtr, UInt elementHash)
 
template<typename MAINCLASS , typename HELPERCLASS >
Result< void > WriteHelper (DataSerializeInterface *ds, void *classPtr, void *helperPtr, UInt elementHash)
 
template<typename T >
void ArrayConversionHelper (void *arrayPtr, Char *memBuffer)
 
template<typename T >
void SetConversionHelper (void *mapPtr, Char *memBuffer)
 
template<typename T >
void MapConversionHelper (void *mapPtr, Char *memBuffer)
 
DESCRIBEFLAGS operator| (DESCRIBEFLAGS a, DESCRIBEFLAGS b)
 
DESCRIBEFLAGS operator& (DESCRIBEFLAGS a, DESCRIBEFLAGS b)
 
DESCRIBEFLAGS operator~ (DESCRIBEFLAGS a)
 
DESCRIBEFLAGS & operator&= (DESCRIBEFLAGS &a, DESCRIBEFLAGS b)
 
enum maxon::PREPAREHELPERFLAGS MAXON_ENUM_FLAGS (PREPAREHELPERFLAGS)
 
 MAXON_DECLARATION (Class< DataSerializeRef >, DataSerializeBaseClass, "net.maxon.class.dataserializebase")
 
 MAXON_DECLARATION (Class< DataSerializeReaderRef >, DataSerializeReaderClass, "net.maxon.class.dataserializereader")
 
 MAXON_DECLARATION (Class< DataSerializeWriterRef >, DataSerializeWriterClass, "net.maxon.class.dataserializewriter")
 
template<typename T , GET_DATATYPE_POLICY POLICY>
Result< const DataType * > CheckedGetDataType ()
 
template<GET_DATATYPE_POLICY POLICY>
ResultOk< const DataType * > PrivateGetDataType (GenericArithmetic *, OverloadRank0)
 
template<GET_DATATYPE_POLICY POLICY, typename T >
SFINAEHelper< Result< const DataType * >, typename T::Unresolved >::type PrivateGetDataType (T *, OverloadRank0)
 
template<GET_DATATYPE_POLICY POLICY, typename T >
SFINAEHelper< Result< const DataType * >, typename T::StaticMTable >::type PrivateGetDataType (T *, OverloadRank1)
 
template<GET_DATATYPE_POLICY POLICY>
Result< const DataType * > PrivateGetDataType (void *, OverloadRank0)
 
template<GET_DATATYPE_POLICY POLICY, typename T >
std::enable_if< GetDirectlyReferencedType< T >::value, Result< const DataType * > >::type PrivateGetDataType (T *, OverloadRank0)
 
template<GET_DATATYPE_POLICY POLICY, typename T >
Result< const DataType * > PrivateGetDataType (T **, OverloadRank0)
 
template<GET_DATATYPE_POLICY POLICY, typename T >
Result< const DataType * > PrivateGetDataType (Pointer< T > *, OverloadRank0)
 
template<GET_DATATYPE_POLICY POLICY, typename T >
Result< const DataType * > PrivateGetDataType (StrongRef< T > *, OverloadRank0)
 
template<GET_DATATYPE_POLICY POLICY, typename T >
Result< const DataType * > PrivateGetDataType (StrongCOWRef< T > *, OverloadRank0)
 
template<GET_DATATYPE_POLICY POLICY, typename T >
Result< const DataType * > PrivateGetDataType (UniqueRef< T > *, OverloadRank0)
 
template<GET_DATATYPE_POLICY POLICY, typename T >
Result< const DataType * > PrivateGetDataType (Block< T > *, OverloadRank0)
 
template<GET_DATATYPE_POLICY POLICY, typename T >
Result< const DataType * > PrivateGetDataType (StridedBlock< T > *, OverloadRank0)
 
template<GET_DATATYPE_POLICY POLICY, typename T >
Result< const DataType * > PrivateGetDataType (Opt< T > *, OverloadRank0)
 
template<GET_DATATYPE_POLICY POLICY, typename T >
Result< const DataType * > PrivateGetDataType (Result< T > *, OverloadRank0)
 
template<GET_DATATYPE_POLICY POLICY, typename T >
Result< const DataType * > PrivateGetDataType (OpaquePtr< T > *, OverloadRank0)
 
template<GET_DATATYPE_POLICY POLICY, typename T >
std::enable_if<(Int(POLICY) &Int(GET_DATATYPE_POLICY::ALLOW_BASEARRAY)) !=0, Result< const DataType * > >::type PrivateGetDataType (BaseArray< T > *, OverloadRank0)
 
template<GET_DATATYPE_POLICY POLICY, typename... T>
Result< const TupleDataType * > PrivateGetDataType (Tuple< T... > *, OverloadRank0)
 
template<GET_DATATYPE_POLICY POLICY, typename R , typename... ARGS>
Result< const DelegateDataType * > PrivateGetDataType (Delegate< R(ARGS...)> *, OverloadRank2)
 
template<GET_DATATYPE_POLICY POLICY>
ResultOk< const DataType * > PrivateGetDataType (const DataType **, OverloadRank0)
 
template<GET_DATATYPE_POLICY POLICY>
ResultOk< const DataType * > PrivateGetDataType (const TupleDataType **, OverloadRank0)
 
String ToString (const TupleDataType *type, const FormatStatement *formatStatement, Bool=false)
 
template<typename T >
void PrivateDataTypeMarker (T *)
 
 MAXON_REGISTRY (const DataType *, DataTypes, "net.maxon.registry.datatypes")
 
void * PrivateDataTypeMarker (Char *)
 
 MAXON_DECLARATION (const maxon::DataType *, DT_Char, "char")
 
template<maxon::GET_DATATYPE_POLICY >
maxon::ResultOk< const maxon::DataType * > PrivateGetDataType (Char *, maxon::OverloadRank2)
 
void * PrivateDataTypeMarker (UChar *)
 
 MAXON_DECLARATION (const maxon::DataType *, DT_UChar, "uchar")
 
template<maxon::GET_DATATYPE_POLICY >
maxon::ResultOk< const maxon::DataType * > PrivateGetDataType (UChar *, maxon::OverloadRank2)
 
void * PrivateDataTypeMarker (Int16 *)
 
 MAXON_DECLARATION (const maxon::DataType *, DT_Int16, "int16")
 
template<maxon::GET_DATATYPE_POLICY >
maxon::ResultOk< const maxon::DataType * > PrivateGetDataType (Int16 *, maxon::OverloadRank2)
 
void * PrivateDataTypeMarker (UInt16 *)
 
 MAXON_DECLARATION (const maxon::DataType *, DT_UInt16, "uint16")
 
template<maxon::GET_DATATYPE_POLICY >
maxon::ResultOk< const maxon::DataType * > PrivateGetDataType (UInt16 *, maxon::OverloadRank2)
 
void * PrivateDataTypeMarker (Int32 *)
 
 MAXON_DECLARATION (const maxon::DataType *, DT_Int32, "int32")
 
template<maxon::GET_DATATYPE_POLICY >
maxon::ResultOk< const maxon::DataType * > PrivateGetDataType (Int32 *, maxon::OverloadRank2)
 
void * PrivateDataTypeMarker (UInt32 *)
 
 MAXON_DECLARATION (const maxon::DataType *, DT_UInt32, "uint32")
 
template<maxon::GET_DATATYPE_POLICY >
maxon::ResultOk< const maxon::DataType * > PrivateGetDataType (UInt32 *, maxon::OverloadRank2)
 
void * PrivateDataTypeMarker (Int64 *)
 
 MAXON_DECLARATION (const maxon::DataType *, DT_Int64, "int64")
 
template<maxon::GET_DATATYPE_POLICY >
maxon::ResultOk< const maxon::DataType * > PrivateGetDataType (Int64 *, maxon::OverloadRank2)
 
void * PrivateDataTypeMarker (UInt64 *)
 
 MAXON_DECLARATION (const maxon::DataType *, DT_UInt64, "uint64")
 
template<maxon::GET_DATATYPE_POLICY >
maxon::ResultOk< const maxon::DataType * > PrivateGetDataType (UInt64 *, maxon::OverloadRank2)
 
void * PrivateDataTypeMarker (Utf16Char *)
 
 MAXON_DECLARATION (const maxon::DataType *, DT_Utf16Char, "utf16char")
 
template<maxon::GET_DATATYPE_POLICY >
maxon::ResultOk< const maxon::DataType * > PrivateGetDataType (Utf16Char *, maxon::OverloadRank2)
 
void * PrivateDataTypeMarker (Utf32Char *)
 
 MAXON_DECLARATION (const maxon::DataType *, DT_Utf32Char, "utf32char")
 
template<maxon::GET_DATATYPE_POLICY >
maxon::ResultOk< const maxon::DataType * > PrivateGetDataType (Utf32Char *, maxon::OverloadRank2)
 
void * PrivateDataTypeMarker (Float32 *)
 
 MAXON_DECLARATION (const maxon::DataType *, DT_Float32, "float32")
 
template<maxon::GET_DATATYPE_POLICY >
maxon::ResultOk< const maxon::DataType * > PrivateGetDataType (Float32 *, maxon::OverloadRank2)
 
void * PrivateDataTypeMarker (Float64 *)
 
 MAXON_DECLARATION (const maxon::DataType *, DT_Float64, "float64")
 
template<maxon::GET_DATATYPE_POLICY >
maxon::ResultOk< const maxon::DataType * > PrivateGetDataType (Float64 *, maxon::OverloadRank2)
 
void * PrivateDataTypeMarker (Bool *)
 
 MAXON_DECLARATION (const maxon::DataType *, DT_Bool, "bool")
 
template<maxon::GET_DATATYPE_POLICY >
maxon::ResultOk< const maxon::DataType * > PrivateGetDataType (Bool *, maxon::OverloadRank2)
 
void * PrivateDataTypeMarker (Byte *)
 
 MAXON_DECLARATION (const maxon::DataType *, DT_Byte, "byte")
 
template<maxon::GET_DATATYPE_POLICY >
maxon::ResultOk< const maxon::DataType * > PrivateGetDataType (Byte *, maxon::OverloadRank2)
 
void * PrivateDataTypeMarker (Id *)
 
 MAXON_DECLARATION (const maxon::DataType *, DT_Id, "net.maxon.datatype.id")
 
template<maxon::GET_DATATYPE_POLICY >
maxon::ResultOk< const maxon::DataType * > PrivateGetDataType (Id *, maxon::OverloadRank2)
 
void * PrivateDataTypeMarker (InternedId *)
 
 MAXON_DECLARATION (const maxon::DataType *, DT_InternedId, "net.maxon.datatype.internedid")
 
template<maxon::GET_DATATYPE_POLICY >
maxon::ResultOk< const maxon::DataType * > PrivateGetDataType (InternedId *, maxon::OverloadRank2)
 
void * PrivateDataTypeMarker (Data *)
 
 MAXON_DECLARATION (const maxon::DataType *, DT_Data, "net.maxon.datatype.data")
 
template<maxon::GET_DATATYPE_POLICY >
maxon::ResultOk< const maxon::DataType * > PrivateGetDataType (Data *, maxon::OverloadRank2)
 
void * PrivateDataTypeMarker (UnitType *)
 
 MAXON_DECLARATION (const maxon::DataType *, DT_UnitType, "net.maxon.datatype.unittype")
 
template<maxon::GET_DATATYPE_POLICY >
maxon::ResultOk< const maxon::DataType * > PrivateGetDataType (UnitType *, maxon::OverloadRank2)
 
void * PrivateDataTypeMarker (SourceLocation *)
 
 MAXON_DECLARATION (const maxon::DataType *, DT_SourceLocation, "net.maxon.datatype.sourcelocation")
 
template<maxon::GET_DATATYPE_POLICY >
maxon::ResultMemT< const maxon::DataType * > PrivateGetDataType (SourceLocation *, maxon::OverloadRank2)
 
 MAXON_ASSERT_LEGAL_LAYOUT (SourceLocation)
 
void * PrivateDataTypeMarker (DelegateBase *)
 
 MAXON_DECLARATION (const maxon::DataType *, DT_DelegateBase, "net.maxon.datatype.delegatebase")
 
template<maxon::GET_DATATYPE_POLICY >
maxon::ResultMemT< const maxon::DataType * > PrivateGetDataType (DelegateBase *, maxon::OverloadRank2)
 
 MAXON_ASSERT_LEGAL_LAYOUT (DelegateBase)
 
void * PrivateDataTypeMarker (AInt *)
 
 MAXON_DECLARATION (const maxon::DataType *, DT_AInt, "int")
 
template<maxon::GET_DATATYPE_POLICY >
maxon::ResultMemT< const maxon::DataType * > PrivateGetDataType (AInt *, maxon::OverloadRank2)
 
 MAXON_ASSERT_LEGAL_LAYOUT (AInt)
 
void * PrivateDataTypeMarker (AUInt *)
 
 MAXON_DECLARATION (const maxon::DataType *, DT_AUInt, "uint")
 
template<maxon::GET_DATATYPE_POLICY >
maxon::ResultMemT< const maxon::DataType * > PrivateGetDataType (AUInt *, maxon::OverloadRank2)
 
 MAXON_ASSERT_LEGAL_LAYOUT (AUInt)
 
void * PrivateDataTypeMarker (AFloat *)
 
 MAXON_DECLARATION (const maxon::DataType *, DT_AFloat, "float")
 
template<maxon::GET_DATATYPE_POLICY >
maxon::ResultMemT< const maxon::DataType * > PrivateGetDataType (AFloat *, maxon::OverloadRank2)
 
 MAXON_ASSERT_LEGAL_LAYOUT (AFloat)
 
template<Bool , typename T >
Result< const DataType * > PrivateGetEnumDataType (T *, OverloadRank0)
 
template<GET_DATATYPE_POLICY POLICY, typename T >
std::enable_if< std::is_enum< T >::value, Result< const DataType * > >::type PrivateGetDataType (T *, OverloadRank0)
 
template<GET_DATATYPE_POLICY POLICY>
ResultOk< const DataType * > PrivateGetDataType (ParametricType *, OverloadRank0)
 
template<GET_DATATYPE_POLICY POLICY>
ResultOk< const DataType * > PrivateGetDataType (ComponentDescriptor *, OverloadRank0)
 
template<typename T , GET_DATATYPE_POLICY POLICY>
const DataType * GetDataType ()
 
template<GET_DATATYPE_POLICY POLICY>
ResultOk< const DataType * > PrivateGetDataType (Generic *, OverloadRank0)
 
void * PrivateDataTypeMarker (ConstDataPtr *)
 
 MAXON_DECLARATION (const maxon::DataType *, DT_ConstDataPtr, "net.maxon.datatype.constdataptr")
 
template<maxon::GET_DATATYPE_POLICY >
maxon::ResultMemT< const maxon::DataType * > PrivateGetDataType (ConstDataPtr *, maxon::OverloadRank2)
 
 MAXON_ASSERT_LEGAL_LAYOUT (ConstDataPtr)
 
void * PrivateDataTypeMarker (DataPtr *)
 
 MAXON_DECLARATION (const maxon::DataType *, DT_DataPtr, "net.maxon.datatype.dataptr")
 
template<maxon::GET_DATATYPE_POLICY >
maxon::ResultMemT< const maxon::DataType * > PrivateGetDataType (DataPtr *, maxon::OverloadRank2)
 
 MAXON_ASSERT_LEGAL_LAYOUT (DataPtr)
 
void * PrivateDataTypeMarker (MoveDataPtr *)
 
 MAXON_DECLARATION (const maxon::DataType *, DT_MoveDataPtr, "net.maxon.datatype.movedataptr")
 
template<maxon::GET_DATATYPE_POLICY >
maxon::ResultMemT< const maxon::DataType * > PrivateGetDataType (MoveDataPtr *, maxon::OverloadRank2)
 
 MAXON_ASSERT_LEGAL_LAYOUT (MoveDataPtr)
 
void * PrivateDataTypeMarker (ForwardingDataPtr *)
 
 MAXON_DECLARATION (const maxon::DataType *, DT_ForwardingDataPtr, "net.maxon.datatype.forwardingdataptr")
 
template<maxon::GET_DATATYPE_POLICY >
maxon::ResultMemT< const maxon::DataType * > PrivateGetDataType (ForwardingDataPtr *, maxon::OverloadRank2)
 
 MAXON_ASSERT_LEGAL_LAYOUT (ForwardingDataPtr)
 
void * PrivateDataTypeMarker (Member *)
 
 MAXON_DECLARATION (const maxon::DataType *, DT_Member, "net.maxon.datatype.member")
 
template<maxon::GET_DATATYPE_POLICY >
maxon::ResultMemT< const maxon::DataType * > PrivateGetDataType (Member *, maxon::OverloadRank2)
 
 MAXON_ASSERT_LEGAL_LAYOUT (Member)
 
template<GET_DATATYPE_POLICY POLICY, typename... T>
Result< const TupleDataType * > PrivateGetDataType (NamedTuple< T... > *, OverloadRank0)
 
enum maxon::INNERMOST_MEMBER Int32 MAXON_ENUM_ORDERED_LIST (INNERMOST_MEMBER)
 
template<GET_DATATYPE_POLICY POLICY, typename T , T C>
Result< const DataType * > PrivateGetDataType (std::integral_constant< T, C > *, OverloadRank0)
 
 MAXON_DATATYPE_EARLY_ENUM (WRITEMETA)
 
 MAXON_DATATYPE_EARLY_ENUM (TARGETAUDIENCE)
 
 MAXON_DATATYPE_EARLY_ENUM (OUTPUT)
 
 MAXON_DATATYPE_EARLY_ENUM (VALUEKIND)
 
 MAXON_DATATYPE_EARLY_ENUM (COMPARERESULT)
 
 MAXON_DATATYPE_EARLY_ENUM (EQUALITY)
 
 MAXON_DATATYPE_EARLY_ENUM (COLLECTION_RESIZE_FLAGS)
 
enum maxon::CONVERSION_FLAGS MAXON_ENUM_FLAGS (CONVERSION_FLAGS)
 
 MAXON_ASSERT_STANDARD_LAYOUT (DataType)
 
enum maxon::GET_DATATYPE_POLICY MAXON_ENUM_FLAGS (GET_DATATYPE_POLICY)
 
 MAXON_DETECT_MEMBER_HELPER (DescribeIO, const DataSerializeInterface &)
 
template<typename T >
Result< void > DescribeIO (const T &s, const DataSerializeInterface &dsi)
 
enum maxon::DATATYPEMODE MAXON_ENUM_LIST (DATATYPEMODE)
 
Result< void * > DecltypeNewInstanceHelper (const void *)
 
template<typename T >
static Result< void * > PrivateNewInterfaceInstance (OverloadRank0)
 
template<typename T >
static decltype(DecltypeNewInstanceHelper(T::Alloc(maxon::SourceLocation()))) MAXON_WARN_UNUSED PrivateNewInterfaceInstance (OverloadRank1)
 
enum maxon::DAYOFWEEK MAXON_ENUM_LIST (DAYOFWEEK)
 
enum maxon::DST Int16 MAXON_ENUM_LIST (DST)
 
enum maxon::JULIANDATE MAXON_ENUM_LIST (JULIANDATE)
 
 MAXON_DATATYPE (UniversalDateTime, "net.maxon.datatype.universaldatetime")
 
 MAXON_DATATYPE (LocalDateTime, "net.maxon.datatype.localdatetime")
 
enum maxon::HARDWAREBREAKPOINTTYPE MAXON_ENUM_LIST (HARDWAREBREAKPOINTTYPE)
 
enum maxon::HARDWAREBREAKPOINTSIZE MAXON_ENUM_LIST (HARDWAREBREAKPOINTSIZE)
 
Int sprintf_safe (Char *_DstBuf, Int _MaxCount, const Char *_Format,...)
 
 MAXON_DECLARATION (ComponentDescriptor, EagerDecoratorComponent, "net.maxon.component.eagerdecorator")
 
template<typename T >
MAXON_ATTRIBUTE_FORCE_INLINE ResultPtr< T > _ReallocMem (T *p, Int cnt, MAXON_SOURCE_LOCATION_DECLARATION)
 
template<typename T >
void DeleteMem (T *&p)
 
void DeleteConstPtrMem (const void *p)
 
MAXON_ATTRIBUTE_FORCE_INLINE void MemCopy (void *dst, const void *src, Int size)
 
MAXON_ATTRIBUTE_FORCE_INLINE void MemMove (void *dst, const void *src, Int size)
 
template<typename T >
MAXON_ATTRIBUTE_FORCE_INLINE void MemCopyType (T *dst, const T *src, Int cnt)
 
template<typename T >
MAXON_ATTRIBUTE_FORCE_INLINE void MemMoveType (T *dst, const T *src, Int cnt)
 
MAXON_ATTRIBUTE_FORCE_INLINE void ClearMem (void *mem, Int size, UChar value=0)
 
MAXON_ATTRIBUTE_FORCE_INLINE void SecureClearMem (volatile void *mem, Int size, UChar value=0)
 
MAXON_ATTRIBUTE_FORCE_INLINE Int CompareMem (const void *block1, const void *block2, Int size)
 
template<typename T >
MAXON_ATTRIBUTE_FORCE_INLINE void ClearMemType (T *data_ptr, Int cnt, UChar value=0)
 
void operator% (const Result< Bool > &res, Result< Bool > &yieldResult)
 
void operator% (const Result< void > &res, Result< Bool > &yieldResult)
 
template<typename NAMED_TUPLE , Bool PTR_FOR_REF>
 MAXON_IMPLEMENTATION_REGISTER_SIMPLE (DynamicTupleImpl< NAMED_TUPLE MAXON_COMMA PTR_FOR_REF >, typename)
 
 MAXON_DECLARATION (Class< Error >, ErrorObjectClass, "net.maxon.class.errorobject")
 
 MAXON_DECLARATION (AggregatedError, AggregatedErrorObject, "net.maxon.object.aggregatederror")
 
MAXON_ATTRIBUTE_FORCE_INLINE void operator% (ErrorPtr &rv, ThreadReferencedError &err)
 
template<typename R >
R Cast (ErrorPtr &ref)
 
template<typename ERRORTYPE >
Bool IsErrorOfType (const Error &err)
 
 MAXON_REGISTRY (JobRef, ExecutionJobs, "net.maxon.registry.executionjobs")
 
 MAXON_MEMBERTYPE_DETECTOR (IsFidClass, FidType, std::false_type)
 
template<typename RESTRICT , Bool ONLYFID, typename KEY >
std::enable_if<!IsFidClass< KEY >::value, typename std::conditional< std::is_reference< KEY >::value||std::is_const< KEY >::value, ConstDataPtr, MoveDataPtr >::type >::type ConvertKeyToDataPtr (KEY &&key)
 
template<typename RESTRICT , Bool ONLYFID, typename KEY >
std::enable_if< IsFidClass< KEY >::value, ConstDataPtr >::type ConvertKeyToDataPtr (KEY &&key)
 
template<typename T >
RESTRICT TestRestriction (T y, OverloadRank0)
 
 MAXON_MEMBERTYPE_DETECTOR (GetRestrict, RESTRICT_DICTIONARY_PROPS, maxon::RESTRICT)
 
Bool IsSourceControlAvailable ()
 
 MAXON_REGISTRY (FileFormat, FileFormats, "net.maxon.registry.fileformats")
 
 MAXON_DECLARATION (Class< FileFormat >, FileFormatBaseClass, "net.maxon.class.fileformatbase")
 
 MAXON_DECLARATION (Class< FileFormatDetectionCacheRef >, FileFormatDetectionCacheClass, "net.maxon.class.fileformatdetectioncache")
 
enum maxon::FILEFORMAT_PRIORITY MAXON_ENUM_LIST (FILEFORMAT_PRIORITY)
 
FILEFORMAT_PRIORITY operator+ (FILEFORMAT_PRIORITY s1, FILEFORMAT_PRIORITY s2)
 
FILEFORMAT_PRIORITY operator- (FILEFORMAT_PRIORITY s1, FILEFORMAT_PRIORITY s2)
 
 MAXON_REGISTRY (FileFormatHandler, FileFormatHandlers, "net.maxon.registry.fileformathandlers")
 
 MAXON_MEMBERTYPE_DETECTOR (GetNonConstIteratorType, Iterator, std::false_type)
 
 MAXON_MEMBERTYPE_DETECTOR (GetConstIteratorType, ConstIterator, std::false_type)
 
 MAXON_MEMBERTYPE_DETECTOR (GetCollectionType, CollectionType, T)
 
 MAXON_MEMBERTYPE_DETECTOR (IsForEachIterator, IsForEachIterator, std::false_type)
 
template<typename I >
ReverseIterator< typename GetIteratorType< typename std::remove_reference< I >::type >::type > RBegin (I &&iterable)
 
template<typename I >
ReverseIterator< typename GetIteratorType< typename std::remove_reference< I >::type >::type > REnd (I &&iterable)
 
template<typename COLLECTION >
MAXON_ATTRIBUTE_FORCE_INLINE auto begin (COLLECTION &&c) -> decltype(c.Begin())
 
template<typename COLLECTION >
MAXON_ATTRIBUTE_FORCE_INLINE auto end (COLLECTION &&c) -> decltype(c.End())
 
Bool CompareFloatTolerant (Float32 a, Float32 b)
 
Bool CompareFloatTolerant (Float64 a, Float64 b)
 
Bool CheckFloat (Float32 r)
 
Bool CheckFloat (Float64 r)
 
Float32 RepairFloat (Float32 r)
 
Float64 RepairFloat (Float64 r)
 
Float32 BoxStep (Float32 lowerLimit, Float32 upperLimit, Float32 x)
 
Float64 BoxStep (Float64 lowerLimit, Float64 upperLimit, Float64 x)
 
Float32 SmoothStep (Float32 lowerLimit, Float32 upperLimit, Float32 x)
 
Float64 SmoothStep (Float64 lowerLimit, Float64 upperLimit, Float64 x)
 
Float32 Modulo (Float32 a, Float32 b)
 
Float64 Modulo (Float64 a, Float64 b)
 
Int32 Modulo (Int32 a, Int32 b)
 
Int64 Modulo (Int64 a, Int64 b)
 
Float32 Bias (Float32 b, Float32 x)
 
Float64 Bias (Float64 b, Float64 x)
 
Float32 Truncate (Float32 x)
 
Float64 Truncate (Float64 x)
 
template<GET_DATATYPE_POLICY POLICY, typename SIG >
Result< const DataType * > PrivateGetDataType (Function< SIG > *, OverloadRank0)
 
enum maxon::HASHMAP_ENTRY_LAYOUT MAXON_ENUM_LIST (HASHMAP_ENTRY_LAYOUT)
 
 MAXON_DECLARATION (Class< HierarchyObjectRef >, HierarchyObjectClass, "net.maxon.class.hierarchyobject")
 
template<typename REFTYPE >
static Result< Bool > TraverseMeAndChildren (const REFTYPE &t, const REFTYPE &parent, const ConstDataPtr &branch, const Delegate< Result< Bool >(const REFTYPE &child, const REFTYPE &parent, const ConstDataPtr &branch, Int depth)> &func, Int depth=0)
 
template<typename REFTYPE >
static Result< Bool > TraverseChildren (const REFTYPE &t, const ConstDataPtr &branch, const Delegate< Result< Bool >(const REFTYPE &child, const REFTYPE &parent, const ConstDataPtr &branch, Int depth)> &func, Int depth)
 
enum maxon::ASSET_UPDATE_POLICY MAXON_ENUM_LIST (ASSET_UPDATE_POLICY, "net.maxon.datatype.enum.asset_update_policy")
 
Bool LessThan (UInt a1, UInt a2, UInt b1, UInt b2)