Namespace Unity.Collections

Classes

AllocatorManager

CollectionHelper

Extensions

JobNativeMultiHashMapUniqueHashExtensions

JobNativeMultiHashMapVisitKeyMutableValue

JobNativeMultiHashMapVisitKeyValue

JobUnsafeMultiHashMapUniqueHashExtensions

JobUnsafeMultiHashMapVisitKeyMutableValue

JobUnsafeMultiHashMapVisitKeyValue

ListExtensions

List extensions.

NativeArrayExtensions

NativeArray extension methods.

NativeHashMapExtensions

NativeSortExtension

WordStorage

Structs

AllocatorManager.AllocatorHandle

Which allocator a Block's Range allocates from.

AllocatorManager.AllocatorInstallation<T>

Mapping between a Block, AllocatorHandle, and an IAllocator.

AllocatorManager.Block

A block of memory with a Range and metadata for size in bytes of each item in the block, number of allocated items, and alignment.

AllocatorManager.BlockHandle

AllocatorManager.Range

Pointer for the beginning of a block of memory, number of items in it, which allocator it belongs to, and which block this is.

BitField32

Fixed size 32-bit array of bits.

BitField64

Fixed size 64-bit array of bits.

Bytes1

Bytes126

Bytes16

Bytes30

Bytes4094

Bytes510

Bytes62

FixedList128<T>

An unmanaged, resizable list that does not allocate memory. It is 128 bytes in size, and contains all the memory it needs.

FixedList128<T>.Enumerator

FixedList32<T>

An unmanaged, resizable list that does not allocate memory. It is 32 bytes in size, and contains all the memory it needs.

FixedList32<T>.Enumerator

FixedList4096<T>

An unmanaged, resizable list that does not allocate memory. It is 4096 bytes in size, and contains all the memory it needs.

FixedList4096<T>.Enumerator

FixedList512<T>

An unmanaged, resizable list that does not allocate memory. It is 512 bytes in size, and contains all the memory it needs.

FixedList512<T>.Enumerator

FixedList64<T>

An unmanaged, resizable list that does not allocate memory. It is 64 bytes in size, and contains all the memory it needs.

FixedList64<T>.Enumerator

FixedListByte128

An unmanaged, resizable list of byte that does not allocate memory. It is 128 bytes in size, and contains all the memory it needs.

FixedListByte128.Enumerator

FixedListByte32

An unmanaged, resizable list of byte that does not allocate memory. It is 32 bytes in size, and contains all the memory it needs.

FixedListByte32.Enumerator

FixedListByte4096

An unmanaged, resizable list of byte that does not allocate memory. It is 4096 bytes in size, and contains all the memory it needs.

FixedListByte4096.Enumerator

FixedListByte512

An unmanaged, resizable list of byte that does not allocate memory. It is 512 bytes in size, and contains all the memory it needs.

FixedListByte512.Enumerator

FixedListByte64

An unmanaged, resizable list of byte that does not allocate memory. It is 64 bytes in size, and contains all the memory it needs.

FixedListByte64.Enumerator

FixedListFloat128

An unmanaged, resizable list of float that does not allocate memory. It is 128 bytes in size, and contains all the memory it needs.

FixedListFloat128.Enumerator

FixedListFloat32

An unmanaged, resizable list of float that does not allocate memory. It is 32 bytes in size, and contains all the memory it needs.

FixedListFloat32.Enumerator

FixedListFloat4096

An unmanaged, resizable list of float that does not allocate memory. It is 4096 bytes in size, and contains all the memory it needs.

FixedListFloat4096.Enumerator

FixedListFloat512

An unmanaged, resizable list of float that does not allocate memory. It is 512 bytes in size, and contains all the memory it needs.

FixedListFloat512.Enumerator

FixedListFloat64

An unmanaged, resizable list of float that does not allocate memory. It is 64 bytes in size, and contains all the memory it needs.

FixedListFloat64.Enumerator

FixedListInt128

An unmanaged, resizable list of int that does not allocate memory. It is 128 bytes in size, and contains all the memory it needs.

FixedListInt128.Enumerator

FixedListInt32

An unmanaged, resizable list of int that does not allocate memory. It is 32 bytes in size, and contains all the memory it needs.

FixedListInt32.Enumerator

FixedListInt4096

An unmanaged, resizable list of int that does not allocate memory. It is 4096 bytes in size, and contains all the memory it needs.

FixedListInt4096.Enumerator

FixedListInt512

An unmanaged, resizable list of int that does not allocate memory. It is 512 bytes in size, and contains all the memory it needs.

FixedListInt512.Enumerator

FixedListInt64

An unmanaged, resizable list of int that does not allocate memory. It is 64 bytes in size, and contains all the memory it needs.

FixedListInt64.Enumerator

FixedString

FixedString128

An unmanaged string in UTF-8 format that contains its own fixed-size buffer of the given size in bytes. The string is NOT guaranteed to be null-terminated, though in many cases it may be by accident. No memory is ever allocated, and no attempt is made to share memory when strings are copied. Since this structure is not generic and needs no disposing, it can exist inside ECS components, can be put in a FixedArray, FixedList or FixedHashMap, and can be a data member of unmanaged structs that are allocated from the unmanaged heap. This string is entirely compatible with Burst compilation.

The binary layout of this string is guaranteed, for now and all time, to be two bytes of little-endian length, followed by a contiguous array of bytes with that length, with no padding in between. This is intentionally identical to FixedList of byte, which is guaranteed to always have the same memory layout.

Those who need more than 65,535 contiguous items should allocate from the heap, as storing that many things contiguously in a C# struct is likely to result in much wasted time, as the compiler copies the struct often.

FixedString128.Enumerator

FixedString32

An unmanaged string in UTF-8 format that contains its own fixed-size buffer of the given size in bytes. The string is NOT guaranteed to be null-terminated, though in many cases it may be by accident. No memory is ever allocated, and no attempt is made to share memory when strings are copied. Since this structure is not generic and needs no disposing, it can exist inside ECS components, can be put in a FixedArray, FixedList or FixedHashMap, and can be a data member of unmanaged structs that are allocated from the unmanaged heap. This string is entirely compatible with Burst compilation.

The binary layout of this string is guaranteed, for now and all time, to be two bytes of little-endian length, followed by a contiguous array of bytes with that length, with no padding in between. This is intentionally identical to FixedList of byte, which is guaranteed to always have the same memory layout.

Those who need more than 65,535 contiguous items should allocate from the heap, as storing that many things contiguously in a C# struct is likely to result in much wasted time, as the compiler copies the struct often.

FixedString32.Enumerator

FixedString4096

An unmanaged string in UTF-8 format that contains its own fixed-size buffer of the given size in bytes. The string is NOT guaranteed to be null-terminated, though in many cases it may be by accident. No memory is ever allocated, and no attempt is made to share memory when strings are copied. Since this structure is not generic and needs no disposing, it can exist inside ECS components, can be put in a FixedArray, FixedList or FixedHashMap, and can be a data member of unmanaged structs that are allocated from the unmanaged heap. This string is entirely compatible with Burst compilation.

The binary layout of this string is guaranteed, for now and all time, to be two bytes of little-endian length, followed by a contiguous array of bytes with that length, with no padding in between. This is intentionally identical to FixedList of byte, which is guaranteed to always have the same memory layout.

Those who need more than 65,535 contiguous items should allocate from the heap, as storing that many things contiguously in a C# struct is likely to result in much wasted time, as the compiler copies the struct often.

FixedString4096.Enumerator

FixedString512

An unmanaged string in UTF-8 format that contains its own fixed-size buffer of the given size in bytes. The string is NOT guaranteed to be null-terminated, though in many cases it may be by accident. No memory is ever allocated, and no attempt is made to share memory when strings are copied. Since this structure is not generic and needs no disposing, it can exist inside ECS components, can be put in a FixedArray, FixedList or FixedHashMap, and can be a data member of unmanaged structs that are allocated from the unmanaged heap. This string is entirely compatible with Burst compilation.

The binary layout of this string is guaranteed, for now and all time, to be two bytes of little-endian length, followed by a contiguous array of bytes with that length, with no padding in between. This is intentionally identical to FixedList of byte, which is guaranteed to always have the same memory layout.

Those who need more than 65,535 contiguous items should allocate from the heap, as storing that many things contiguously in a C# struct is likely to result in much wasted time, as the compiler copies the struct often.

FixedString512.Enumerator

FixedString64

An unmanaged string in UTF-8 format that contains its own fixed-size buffer of the given size in bytes. The string is NOT guaranteed to be null-terminated, though in many cases it may be by accident. No memory is ever allocated, and no attempt is made to share memory when strings are copied. Since this structure is not generic and needs no disposing, it can exist inside ECS components, can be put in a FixedArray, FixedList or FixedHashMap, and can be a data member of unmanaged structs that are allocated from the unmanaged heap. This string is entirely compatible with Burst compilation.

The binary layout of this string is guaranteed, for now and all time, to be two bytes of little-endian length, followed by a contiguous array of bytes with that length, with no padding in between. This is intentionally identical to FixedList of byte, which is guaranteed to always have the same memory layout.

Those who need more than 65,535 contiguous items should allocate from the heap, as storing that many things contiguously in a C# struct is likely to result in much wasted time, as the compiler copies the struct often.

FixedString64.Enumerator

NativeHashMap<TKey, TValue>

Unordered associative array, a collection of keys and values.

NativeHashMap<TKey, TValue>.ParallelWriter

Implements parallel writer. Use AsParallelWriter to obtain it from container.

NativeKeyValueArrays<TKey, TValue>

Key value arrays.

NativeList<T>

An unmanaged, resizable list.

NativeList<T>.ParallelWriter

NativeMultiHashMap<TKey, TValue>

Unordered associative array, a collection of keys and values. This container can store multiple values for every key.

NativeMultiHashMap<TKey, TValue>.Enumerator

NativeMultiHashMap<TKey, TValue>.ParallelWriter

Implements parallel writer. Use AsParallelWriter to obtain it from container.

NativeMultiHashMapIterator<TKey>

Iterator.

NativeQueue<T>

An unmanaged queue.

NativeQueue<T>.ParallelWriter

Implements parallel writer. Use AsParallelWriter to obtain it from container.

NativeStream

A deterministic data streaming supporting parallel reading and parallel writing. Allows you to write different types or arrays into a single stream.

NativeStream.Reader

NativeStream.Writer

NativeString128

NativeString32

NativeString4096

NativeString512

NativeString64

NativeStringView

NumberedWords

Unicode

Unicode.Rune

Words

Interfaces

AllocatorManager.IAllocator

An allocator with a tryable allocate/free/realloc function pointer.

IJobNativeMultiHashMapMergedSharedKeyIndices

IJobNativeMultiHashMapVisitKeyMutableValue<TKey, TValue>

IJobNativeMultiHashMapVisitKeyValue<TKey, TValue>

IJobUnsafeMultiHashMapMergedSharedKeyIndices

IJobUnsafeMultiHashMapVisitKeyMutableValue<TKey, TValue>

IJobUnsafeMultiHashMapVisitKeyValue<TKey, TValue>

Enums

ConversionError

CopyError

FormatError

ParseError

Delegates

AllocatorManager.TryFunction

Delegate used for calling an allocator's allocation function.