Namespace Unity.Collections | Collections | 0.6.0-preview.9
docs.unity3d.com
    Show / Hide Table of Contents

    Namespace Unity.Collections

    Classes

    ArrayExtensions

    CollectionHelper

    Extensions

    JobNativeMultiHashMapUniqueHashExtensions

    JobNativeMultiHashMapVisitKeyMutableValue

    JobNativeMultiHashMapVisitKeyValue

    JobUnsafeMultiHashMapUniqueHashExtensions

    JobUnsafeMultiHashMapVisitKeyMutableValue

    JobUnsafeMultiHashMapVisitKeyValue

    ListExtensions

    NativeArrayExtensions

    NativeHashMapExtensions

    NativeSortExtension

    WordStorage

    Structs

    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

    IJobNativeMultiHashMapMergedSharedKeyIndices

    IJobNativeMultiHashMapVisitKeyMutableValue<TKey, TValue>

    IJobNativeMultiHashMapVisitKeyValue<TKey, TValue>

    IJobUnsafeMultiHashMapMergedSharedKeyIndices

    IJobUnsafeMultiHashMapVisitKeyMutableValue<TKey, TValue>

    IJobUnsafeMultiHashMapVisitKeyValue<TKey, TValue>

    Enums

    ConversionError

    CopyError

    FormatError

    ParseError

    Back to top
    Copyright © 2023 Unity Technologies — Terms of use
    • Legal
    • Privacy Policy
    • Cookies
    • Do Not Sell or Share My Personal Information
    • Your Privacy Choices (Cookie Settings)
    "Unity", Unity logos, and other Unity trademarks are trademarks or registered trademarks of Unity Technologies or its affiliates in the U.S. and elsewhere (more info here). Other names or brands are trademarks of their respective owners.
    Generated by DocFX on 18 October 2023