1725 lines
68 KiB
C#
1725 lines
68 KiB
C#
using System;
|
|
using System.Collections;
|
|
using System.Collections.Generic;
|
|
using System.Diagnostics;
|
|
using System.Runtime.InteropServices;
|
|
using System.Threading;
|
|
using Unity.Burst;
|
|
using Unity.Jobs;
|
|
using Unity.Mathematics;
|
|
|
|
namespace Unity.Collections.LowLevel.Unsafe
|
|
{
|
|
|
|
[BurstCompile]
|
|
internal unsafe struct UnsafeDisposeJob : IJob
|
|
{
|
|
[NativeDisableUnsafePtrRestriction]
|
|
public void* Ptr;
|
|
public AllocatorManager.AllocatorHandle Allocator;
|
|
|
|
public void Execute()
|
|
{
|
|
AllocatorManager.Free(Allocator, Ptr);
|
|
}
|
|
}
|
|
|
|
internal unsafe struct UntypedUnsafeList
|
|
{
|
|
#pragma warning disable 169
|
|
[NativeDisableUnsafePtrRestriction]
|
|
public void* Ptr;
|
|
public int m_length;
|
|
public int m_capacity;
|
|
public AllocatorManager.AllocatorHandle Allocator;
|
|
internal int obsolete_length;
|
|
internal int obsolete_capacity;
|
|
#pragma warning restore 169
|
|
}
|
|
|
|
/// <summary>
|
|
/// An unmanaged, resizable list.
|
|
/// </summary>
|
|
/// <typeparam name="T">The type of the elements.</typeparam>
|
|
[DebuggerDisplay("Length = {Length}, Capacity = {Capacity}, IsCreated = {IsCreated}, IsEmpty = {IsEmpty}")]
|
|
[DebuggerTypeProxy(typeof(UnsafeListTDebugView<>))]
|
|
[StructLayout(LayoutKind.Sequential)]
|
|
[BurstCompatible(GenericTypeArguments = new[] { typeof(int) })]
|
|
public unsafe struct UnsafeList<T>
|
|
: INativeDisposable
|
|
, INativeList<T>
|
|
, IEnumerable<T> // Used by collection initializers.
|
|
where T : unmanaged
|
|
{
|
|
// <WARNING>
|
|
// 'Header' of this struct must binary match 'UntypedUnsafeList' struct
|
|
// Fields must match UntypedUnsafeList structure, please don't reorder and don't insert anything in between first 4 fields
|
|
|
|
/// <summary>
|
|
/// The internal buffer of this list.
|
|
/// </summary>
|
|
[NativeDisableUnsafePtrRestriction]
|
|
public T* Ptr;
|
|
|
|
/// <summary>
|
|
/// The number of elements.
|
|
/// </summary>
|
|
public int m_length;
|
|
|
|
/// <summary>
|
|
/// The number of elements that can fit in the internal buffer.
|
|
/// </summary>
|
|
public int m_capacity;
|
|
|
|
/// <summary>
|
|
/// The allocator used to create the internal buffer.
|
|
/// </summary>
|
|
public AllocatorManager.AllocatorHandle Allocator;
|
|
|
|
[Obsolete("Use Length property (UnityUpgradable) -> Length", true)]
|
|
public int length;
|
|
|
|
[Obsolete("Use Capacity property (UnityUpgradable) -> Capacity", true)]
|
|
public int capacity;
|
|
|
|
/// <summary>
|
|
/// The number of elements.
|
|
/// </summary>
|
|
/// <value>The number of elements.</value>
|
|
public int Length
|
|
{
|
|
get
|
|
{
|
|
return CollectionHelper.AssumePositive(m_length);
|
|
}
|
|
|
|
set
|
|
{
|
|
if (value > Capacity)
|
|
{
|
|
Resize(value);
|
|
}
|
|
else
|
|
{
|
|
m_length = value;
|
|
}
|
|
}
|
|
}
|
|
|
|
/// <summary>
|
|
/// The number of elements that can fit in the internal buffer.
|
|
/// </summary>
|
|
/// <value>The number of elements that can fit in the internal buffer.</value>
|
|
public int Capacity
|
|
{
|
|
get
|
|
{
|
|
return CollectionHelper.AssumePositive(m_capacity);
|
|
}
|
|
|
|
set
|
|
{
|
|
SetCapacity(value);
|
|
}
|
|
}
|
|
|
|
/// <summary>
|
|
/// The element at an index.
|
|
/// </summary>
|
|
/// <param name="index">An index.</param>
|
|
/// <value>The element at the index.</value>
|
|
public T this[int index]
|
|
{
|
|
get
|
|
{
|
|
CollectionHelper.CheckIndexInRange(index, Length);
|
|
return Ptr[CollectionHelper.AssumePositive(index)];
|
|
}
|
|
|
|
set
|
|
{
|
|
CollectionHelper.CheckIndexInRange(index, Length);
|
|
Ptr[CollectionHelper.AssumePositive(index)] = value;
|
|
}
|
|
}
|
|
|
|
/// <summary>
|
|
/// Returns a reference to the element at a given index.
|
|
/// </summary>
|
|
/// <param name="index">The index to access. Must be in the range of [0..Length).</param>
|
|
/// <returns>A reference to the element at the index.</returns>
|
|
public ref T ElementAt(int index)
|
|
{
|
|
CollectionHelper.CheckIndexInRange(index, Length);
|
|
return ref Ptr[CollectionHelper.AssumePositive(index)];
|
|
}
|
|
|
|
/// <summary>
|
|
/// Initializes and returns an instance of UnsafeList.
|
|
/// </summary>
|
|
/// <param name="ptr">An existing byte array to set as the internal buffer.</param>
|
|
/// <param name="length">The length.</param>
|
|
public UnsafeList(T* ptr, int length) : this()
|
|
{
|
|
Ptr = ptr;
|
|
this.m_length = length;
|
|
m_capacity = 0;
|
|
Allocator = AllocatorManager.None;
|
|
}
|
|
|
|
/// <summary>
|
|
/// Initializes and returns an instance of UnsafeList.
|
|
/// </summary>
|
|
/// <param name="initialCapacity">The initial capacity of the list.</param>
|
|
/// <param name="allocator">The allocator to use.</param>
|
|
/// <param name="options">Whether newly allocated bytes should be zeroed out.</param>
|
|
public UnsafeList(int initialCapacity, AllocatorManager.AllocatorHandle allocator, NativeArrayOptions options = NativeArrayOptions.UninitializedMemory) : this()
|
|
{
|
|
Ptr = null;
|
|
m_length = 0;
|
|
m_capacity = 0;
|
|
Allocator = allocator;
|
|
|
|
if (initialCapacity != 0)
|
|
{
|
|
SetCapacity(initialCapacity);
|
|
}
|
|
|
|
if (options == NativeArrayOptions.ClearMemory && Ptr != null)
|
|
{
|
|
var sizeOf = sizeof(T);
|
|
UnsafeUtility.MemClear(Ptr, Capacity * sizeOf);
|
|
}
|
|
}
|
|
|
|
[BurstCompatible(GenericTypeArguments = new [] { typeof(AllocatorManager.AllocatorHandle) })]
|
|
internal void Initialize<U>(int initialCapacity, ref U allocator, NativeArrayOptions options = NativeArrayOptions.UninitializedMemory) where U : unmanaged, AllocatorManager.IAllocator
|
|
{
|
|
Ptr = null;
|
|
m_length = 0;
|
|
m_capacity = 0;
|
|
Allocator = AllocatorManager.None;
|
|
Initialize(initialCapacity, ref allocator, options);
|
|
}
|
|
|
|
[BurstCompatible(GenericTypeArguments = new [] { typeof(AllocatorManager.AllocatorHandle) })]
|
|
internal static UnsafeList<T> New<U>(int initialCapacity, ref U allocator, NativeArrayOptions options = NativeArrayOptions.UninitializedMemory) where U : unmanaged, AllocatorManager.IAllocator
|
|
{
|
|
UnsafeList<T> instance = default;
|
|
instance.Initialize(initialCapacity, ref allocator, options);
|
|
return instance;
|
|
}
|
|
|
|
[BurstCompatible(GenericTypeArguments = new[] { typeof(AllocatorManager.AllocatorHandle) })]
|
|
internal static UnsafeList<T>* Create<U>(int initialCapacity, ref U allocator, NativeArrayOptions options = NativeArrayOptions.UninitializedMemory) where U : unmanaged, AllocatorManager.IAllocator
|
|
{
|
|
UnsafeList<T>* listData = allocator.Allocate(default(UnsafeList<T>), 1);
|
|
UnsafeUtility.MemClear(listData, sizeof(UnsafeList<T>));
|
|
|
|
listData->Allocator = allocator.Handle;
|
|
|
|
if (initialCapacity != 0)
|
|
{
|
|
listData->SetCapacity(ref allocator, initialCapacity);
|
|
}
|
|
|
|
if (options == NativeArrayOptions.ClearMemory
|
|
&& listData->Ptr != null)
|
|
{
|
|
var sizeOf = sizeof(T);
|
|
UnsafeUtility.MemClear(listData->Ptr, listData->Capacity * sizeOf);
|
|
}
|
|
|
|
return listData;
|
|
}
|
|
|
|
[BurstCompatible(GenericTypeArguments = new[] { typeof(AllocatorManager.AllocatorHandle) })]
|
|
internal static void Destroy<U>(UnsafeList<T>* listData, ref U allocator) where U : unmanaged, AllocatorManager.IAllocator
|
|
{
|
|
CheckNull(listData);
|
|
listData->Dispose(ref allocator);
|
|
allocator.Free(listData, sizeof(UnsafeList<T>), UnsafeUtility.AlignOf<UnsafeList<T>>(), 1);
|
|
}
|
|
|
|
/// <summary>
|
|
/// Returns a new list.
|
|
/// </summary>
|
|
/// <param name="initialCapacity">The initial capacity of the list.</param>
|
|
/// <param name="allocator">The allocator to use.</param>
|
|
/// <param name="options">Whether newly allocated bytes should be zeroed out.</param>
|
|
/// <returns>A pointer to the new list.</returns>
|
|
public static UnsafeList<T>* Create(int initialCapacity, AllocatorManager.AllocatorHandle allocator, NativeArrayOptions options = NativeArrayOptions.UninitializedMemory)
|
|
{
|
|
UnsafeList<T>* listData = AllocatorManager.Allocate<UnsafeList<T>>(allocator);
|
|
*listData = new UnsafeList<T>(initialCapacity, allocator, options);
|
|
|
|
return listData;
|
|
}
|
|
|
|
/// <summary>
|
|
/// Destroys the list.
|
|
/// </summary>
|
|
/// <param name="listData">The list to destroy.</param>
|
|
public static void Destroy(UnsafeList<T>* listData)
|
|
{
|
|
CheckNull(listData);
|
|
var allocator = listData->Allocator;
|
|
listData->Dispose();
|
|
AllocatorManager.Free(allocator, listData);
|
|
}
|
|
|
|
/// <summary>
|
|
/// Whether the list is empty.
|
|
/// </summary>
|
|
/// <value>True if the list is empty or the list has not been constructed.</value>
|
|
public bool IsEmpty => !IsCreated || m_length == 0;
|
|
|
|
/// <summary>
|
|
/// Whether this list has been allocated (and not yet deallocated).
|
|
/// </summary>
|
|
/// <value>True if this list has been allocated (and not yet deallocated).</value>
|
|
public bool IsCreated => Ptr != null;
|
|
|
|
[BurstCompatible(GenericTypeArguments = new[] { typeof(AllocatorManager.AllocatorHandle) })]
|
|
internal void Dispose<U>(ref U allocator) where U : unmanaged, AllocatorManager.IAllocator
|
|
{
|
|
allocator.Free(Ptr, m_length);
|
|
Ptr = null;
|
|
m_length = 0;
|
|
m_capacity = 0;
|
|
}
|
|
|
|
/// <summary>
|
|
/// Releases all resources (memory).
|
|
/// </summary>
|
|
public void Dispose()
|
|
{
|
|
if (CollectionHelper.ShouldDeallocate(Allocator))
|
|
{
|
|
AllocatorManager.Free(Allocator, Ptr);
|
|
Allocator = AllocatorManager.Invalid;
|
|
}
|
|
|
|
Ptr = null;
|
|
m_length = 0;
|
|
m_capacity = 0;
|
|
}
|
|
|
|
/// <summary>
|
|
/// Creates and schedules a job that frees the memory of this list.
|
|
/// </summary>
|
|
/// <param name="inputDeps">The dependency for the new job.</param>
|
|
/// <returns>The handle of the new job. The job depends upon `inputDeps` and frees the memory of this list.</returns>
|
|
[NotBurstCompatible /* This is not burst compatible because of IJob's use of a static IntPtr. Should switch to IJobBurstSchedulable in the future */]
|
|
public JobHandle Dispose(JobHandle inputDeps)
|
|
{
|
|
if (CollectionHelper.ShouldDeallocate(Allocator))
|
|
{
|
|
var jobHandle = new UnsafeDisposeJob { Ptr = Ptr, Allocator = Allocator }.Schedule(inputDeps);
|
|
|
|
Ptr = null;
|
|
Allocator = AllocatorManager.Invalid;
|
|
|
|
return jobHandle;
|
|
}
|
|
|
|
Ptr = null;
|
|
|
|
return inputDeps;
|
|
}
|
|
|
|
/// <summary>
|
|
/// Sets the length to 0.
|
|
/// </summary>
|
|
/// <remarks>Does not change the capacity.</remarks>
|
|
public void Clear()
|
|
{
|
|
m_length = 0;
|
|
}
|
|
|
|
/// <summary>
|
|
/// Sets the length, expanding the capacity if necessary.
|
|
/// </summary>
|
|
/// <param name="length">The new length.</param>
|
|
/// <param name="options">Whether newly allocated bytes should be zeroed out.</param>
|
|
public void Resize(int length, NativeArrayOptions options = NativeArrayOptions.UninitializedMemory)
|
|
{
|
|
var oldLength = m_length;
|
|
|
|
if (length > Capacity)
|
|
{
|
|
SetCapacity(length);
|
|
}
|
|
|
|
m_length = length;
|
|
|
|
if (options == NativeArrayOptions.ClearMemory && oldLength < length)
|
|
{
|
|
var num = length - oldLength;
|
|
byte* ptr = (byte*)Ptr;
|
|
var sizeOf = sizeof(T);
|
|
UnsafeUtility.MemClear(ptr + oldLength * sizeOf, num * sizeOf);
|
|
}
|
|
}
|
|
|
|
void Realloc<U>(ref U allocator, int newCapacity) where U : unmanaged, AllocatorManager.IAllocator
|
|
{
|
|
CollectionHelper.CheckAllocator(Allocator);
|
|
T* newPointer = null;
|
|
|
|
var alignOf = UnsafeUtility.AlignOf<T>();
|
|
var sizeOf = sizeof(T);
|
|
|
|
if (newCapacity > 0)
|
|
{
|
|
newPointer = (T*)allocator.Allocate(sizeOf, alignOf, newCapacity);
|
|
|
|
if (m_capacity > 0)
|
|
{
|
|
var itemsToCopy = math.min(newCapacity, Capacity);
|
|
var bytesToCopy = itemsToCopy * sizeOf;
|
|
UnsafeUtility.MemCpy(newPointer, Ptr, bytesToCopy);
|
|
}
|
|
}
|
|
|
|
allocator.Free(Ptr, Capacity);
|
|
|
|
Ptr = newPointer;
|
|
m_capacity = newCapacity;
|
|
m_length = math.min(m_length, newCapacity);
|
|
}
|
|
|
|
void Realloc(int capacity)
|
|
{
|
|
Realloc(ref Allocator, capacity);
|
|
}
|
|
|
|
void SetCapacity<U>(ref U allocator, int capacity) where U : unmanaged, AllocatorManager.IAllocator
|
|
{
|
|
CollectionHelper.CheckCapacityInRange(capacity, Length);
|
|
|
|
var sizeOf = sizeof(T);
|
|
var newCapacity = math.max(capacity, 64 / sizeOf);
|
|
newCapacity = math.ceilpow2(newCapacity);
|
|
|
|
if (newCapacity == Capacity)
|
|
{
|
|
return;
|
|
}
|
|
|
|
Realloc(ref allocator, newCapacity);
|
|
}
|
|
|
|
/// <summary>
|
|
/// Sets the capacity.
|
|
/// </summary>
|
|
/// <param name="capacity">The new capacity.</param>
|
|
public void SetCapacity(int capacity)
|
|
{
|
|
SetCapacity(ref Allocator, capacity);
|
|
}
|
|
|
|
/// <summary>
|
|
/// Sets the capacity to match the length.
|
|
/// </summary>
|
|
public void TrimExcess()
|
|
{
|
|
if (Capacity != m_length)
|
|
{
|
|
Realloc(m_length);
|
|
}
|
|
}
|
|
|
|
/// <summary>
|
|
/// Adds an element to the end of this list.
|
|
/// </summary>
|
|
/// <remarks>
|
|
/// Increments the length by 1. Never increases the capacity.
|
|
/// </remarks>
|
|
/// <param name="value">The value to add to the end of the list.</param>
|
|
/// <exception cref="Exception">Thrown if incrementing the length would exceed the capacity.</exception>
|
|
public void AddNoResize(T value)
|
|
{
|
|
CheckNoResizeHasEnoughCapacity(1);
|
|
UnsafeUtility.WriteArrayElement(Ptr, m_length, value);
|
|
m_length += 1;
|
|
}
|
|
|
|
/// <summary>
|
|
/// Copies elements from a buffer to the end of this list.
|
|
/// </summary>
|
|
/// <remarks>
|
|
/// Increments the length by `count`. Never increases the capacity.
|
|
/// </remarks>
|
|
/// <param name="ptr">The buffer to copy from.</param>
|
|
/// <param name="count">The number of elements to copy from the buffer.</param>
|
|
/// <exception cref="Exception">Thrown if the increased length would exceed the capacity.</exception>
|
|
public void AddRangeNoResize(void* ptr, int count)
|
|
{
|
|
CheckNoResizeHasEnoughCapacity(count);
|
|
var sizeOf = sizeof(T);
|
|
void* dst = (byte*)Ptr + m_length * sizeOf;
|
|
UnsafeUtility.MemCpy(dst, ptr, count * sizeOf);
|
|
m_length += count;
|
|
}
|
|
|
|
/// <summary>
|
|
/// Copies the elements of another list to the end of this list.
|
|
/// </summary>
|
|
/// <param name="list">The other list to copy from.</param>
|
|
/// <remarks>
|
|
/// Increments the length by the length of the other list. Never increases the capacity.
|
|
/// </remarks>
|
|
/// <exception cref="Exception">Thrown if the increased length would exceed the capacity.</exception>
|
|
[BurstCompatible(GenericTypeArguments = new[] { typeof(int) })]
|
|
public void AddRangeNoResize(UnsafeList<T> list)
|
|
{
|
|
AddRangeNoResize(list.Ptr, CollectionHelper.AssumePositive(list.m_length));
|
|
}
|
|
|
|
/// <summary>
|
|
/// Adds an element to the end of the list.
|
|
/// </summary>
|
|
/// <param name="value">The value to add to the end of this list.</param>
|
|
/// <remarks>
|
|
/// Increments the length by 1. Increases the capacity if necessary.
|
|
/// </remarks>
|
|
public void Add(in T value)
|
|
{
|
|
var idx = m_length;
|
|
|
|
if (m_length + 1 > Capacity)
|
|
{
|
|
Resize(idx + 1);
|
|
}
|
|
else
|
|
{
|
|
m_length += 1;
|
|
}
|
|
|
|
UnsafeUtility.WriteArrayElement(Ptr, idx, value);
|
|
}
|
|
|
|
/// <summary>
|
|
/// Copies the elements of a buffer to the end of this list.
|
|
/// </summary>
|
|
/// <param name="ptr">The buffer to copy from.</param>
|
|
/// <param name="count">The number of elements to copy from the buffer.</param>
|
|
/// <remarks>
|
|
/// Increments the length by `count`. Increases the capacity if necessary.
|
|
/// </remarks>
|
|
public void AddRange(void* ptr, int count)
|
|
{
|
|
var idx = m_length;
|
|
|
|
if (m_length + count > Capacity)
|
|
{
|
|
Resize(m_length + count);
|
|
}
|
|
else
|
|
{
|
|
m_length += count;
|
|
}
|
|
|
|
var sizeOf = sizeof(T);
|
|
void* dst = (byte*)Ptr + idx * sizeOf;
|
|
UnsafeUtility.MemCpy(dst, ptr, count * sizeOf);
|
|
}
|
|
|
|
/// <summary>
|
|
/// Copies the elements of another list to the end of the list.
|
|
/// </summary>
|
|
/// <param name="list">The list to copy from.</param>
|
|
/// <remarks>
|
|
/// The length is increased by the length of the other list. Increases the capacity if necessary.
|
|
/// </remarks>
|
|
[BurstCompatible(GenericTypeArguments = new[] { typeof(int) })]
|
|
public void AddRange(UnsafeList<T> list)
|
|
{
|
|
AddRange(list.Ptr, list.Length);
|
|
}
|
|
|
|
/// <summary>
|
|
/// Shifts elements toward the end of this list, increasing its length.
|
|
/// </summary>
|
|
/// <remarks>
|
|
/// Right-shifts elements in the list so as to create 'free' slots at the beginning or in the middle.
|
|
///
|
|
/// The length is increased by `end - begin`. If necessary, the capacity will be increased accordingly.
|
|
///
|
|
/// If `end` equals `begin`, the method does nothing.
|
|
///
|
|
/// The element at index `begin` will be copied to index `end`, the element at index `begin + 1` will be copied to `end + 1`, and so forth.
|
|
///
|
|
/// The indexes `begin` up to `end` are not cleared: they will contain whatever values they held prior.
|
|
/// </remarks>
|
|
/// <param name="begin">The index of the first element that will be shifted up.</param>
|
|
/// <param name="end">The index where the first shifted element will end up.</param>
|
|
/// <exception cref="ArgumentException">Thrown if `end < begin`.</exception>
|
|
/// <exception cref="ArgumentOutOfRangeException">Thrown if `begin` or `end` are out of bounds.</exception>
|
|
public void InsertRangeWithBeginEnd(int begin, int end)
|
|
{
|
|
CheckBeginEnd(begin, end);
|
|
|
|
int items = end - begin;
|
|
if (items < 1)
|
|
{
|
|
return;
|
|
}
|
|
|
|
var oldLength = m_length;
|
|
|
|
if (m_length + items > Capacity)
|
|
{
|
|
Resize(m_length + items);
|
|
}
|
|
else
|
|
{
|
|
m_length += items;
|
|
}
|
|
|
|
var itemsToCopy = oldLength - begin;
|
|
|
|
if (itemsToCopy < 1)
|
|
{
|
|
return;
|
|
}
|
|
|
|
var sizeOf = sizeof(T);
|
|
var bytesToCopy = itemsToCopy * sizeOf;
|
|
unsafe
|
|
{
|
|
byte* ptr = (byte*)Ptr;
|
|
byte* dest = ptr + end * sizeOf;
|
|
byte* src = ptr + begin * sizeOf;
|
|
UnsafeUtility.MemMove(dest, src, bytesToCopy);
|
|
}
|
|
}
|
|
|
|
/// <summary>
|
|
/// Copies the last element of this list to the specified index. Decrements the length by 1.
|
|
/// </summary>
|
|
/// <remarks>Useful as a cheap way to remove an element from this list when you don't care about preserving order.</remarks>
|
|
/// <param name="index">The index to overwrite with the last element.</param>
|
|
/// <exception cref="IndexOutOfRangeException">Thrown if `index` is out of bounds.</exception>
|
|
public void RemoveAtSwapBack(int index)
|
|
{
|
|
RemoveRangeSwapBack(index, 1);
|
|
}
|
|
|
|
/// <summary>
|
|
/// Copies the last *N* elements of this list to a range in this list. Decrements the length by *N*.
|
|
/// </summary>
|
|
/// <remarks>
|
|
/// Copies the last `count` elements to the indexes `index` up to `index + count`.
|
|
///
|
|
/// Useful as a cheap way to remove elements from a list when you don't care about preserving order.
|
|
/// </remarks>
|
|
/// <param name="index">The index of the first element to overwrite.</param>
|
|
/// <param name="count">The number of elements to copy and remove.</param>
|
|
/// <exception cref="ArgumentOutOfRangeException">Thrown if `index` is out of bounds, `count` is negative,
|
|
/// or `index + count` exceeds the length.</exception>
|
|
public void RemoveRangeSwapBack(int index, int count)
|
|
{
|
|
CheckIndexCount(index, count);
|
|
|
|
if (count > 0)
|
|
{
|
|
int copyFrom = math.max(m_length - count, index + count);
|
|
var sizeOf = sizeof(T);
|
|
void* dst = (byte*)Ptr + index * sizeOf;
|
|
void* src = (byte*)Ptr + copyFrom * sizeOf;
|
|
UnsafeUtility.MemCpy(dst, src, (m_length - copyFrom) * sizeOf);
|
|
m_length -= count;
|
|
}
|
|
}
|
|
|
|
/// <summary>
|
|
/// Copies the last *N* elements of this list to a range in this list. Decrements the length by *N*.
|
|
/// </summary>
|
|
/// <remarks>
|
|
/// Copies the last `end - begin` elements to the indexes `begin` up to `end`.
|
|
///
|
|
/// Useful as a cheap way to remove elements from a list when you don't care about preserving order.
|
|
///
|
|
/// Does nothing if `end - begin` is less than 1.
|
|
/// </remarks>
|
|
/// <param name="begin">The index of the first element to overwrite.</param>
|
|
/// <param name="end">The index one greater than the last element to overwrite.</param>
|
|
/// <exception cref="ArgumentOutOfRangeException">Thrown if `begin` or `end` are out of bounds.</exception>
|
|
[Obsolete("RemoveRangeSwapBackWithBeginEnd(begin, end) is deprecated, use RemoveRangeSwapBack(index, count) instead. (RemovedAfter 2021-06-02)", false)]
|
|
public void RemoveRangeSwapBackWithBeginEnd(int begin, int end)
|
|
{
|
|
CheckBeginEnd(begin, end);
|
|
|
|
int itemsToRemove = end - begin;
|
|
if (itemsToRemove > 0)
|
|
{
|
|
int copyFrom = math.max(m_length - itemsToRemove, end);
|
|
var sizeOf = sizeof(T);
|
|
void* dst = (byte*)Ptr + begin * sizeOf;
|
|
void* src = (byte*)Ptr + copyFrom * sizeOf;
|
|
UnsafeUtility.MemCpy(dst, src, (m_length - copyFrom) * sizeOf);
|
|
m_length -= itemsToRemove;
|
|
}
|
|
}
|
|
|
|
/// <summary>
|
|
/// Removes the element at an index, shifting everything above it down by one. Decrements the length by 1.
|
|
/// </summary>
|
|
/// <param name="index">The index of the element to remove.</param>
|
|
/// <remarks>
|
|
/// If you don't care about preserving the order of the elements, <see cref="RemoveAtSwapBack(int)"/> is a more efficient way to remove elements.
|
|
/// </remarks>
|
|
/// <exception cref="ArgumentOutOfRangeException">Thrown if `index` is out of bounds.</exception>
|
|
public void RemoveAt(int index)
|
|
{
|
|
RemoveRange(index, 1);
|
|
}
|
|
|
|
/// <summary>
|
|
/// Removes *N* elements in a range, shifting everything above the range down by *N*. Decrements the length by *N*.
|
|
/// </summary>
|
|
/// <param name="index">The index of the first element to remove.</param>
|
|
/// <param name="count">The number of elements to remove.</param>
|
|
/// <remarks>
|
|
/// If you don't care about preserving the order of the elements, <see cref="RemoveRangeSwapBackWithBeginEnd"/>
|
|
/// is a more efficient way to remove elements.
|
|
/// </remarks>
|
|
/// <exception cref="ArgumentOutOfRangeException">Thrown if `index` is out of bounds, `count` is negative,
|
|
/// or `index + count` exceeds the length.</exception>
|
|
public void RemoveRange(int index, int count)
|
|
{
|
|
CheckIndexCount(index, count);
|
|
|
|
if (count > 0)
|
|
{
|
|
int copyFrom = math.min(index + count, m_length);
|
|
var sizeOf = sizeof(T);
|
|
void* dst = (byte*)Ptr + index * sizeOf;
|
|
void* src = (byte*)Ptr + copyFrom * sizeOf;
|
|
UnsafeUtility.MemCpy(dst, src, (m_length - copyFrom) * sizeOf);
|
|
m_length -= count;
|
|
}
|
|
}
|
|
|
|
/// <summary>
|
|
/// Removes *N* elements in a range, shifting everything above it down by *N*. Decrements the length by *N*.
|
|
/// </summary>
|
|
/// <param name="begin">The index of the first element to remove.</param>
|
|
/// <param name="end">The index one greater than the last element to remove.</param>
|
|
/// <remarks>
|
|
/// If you don't care about preserving the order of the elements, <see cref="RemoveRangeSwapBackWithBeginEnd"/> is a more efficient way to remove elements.
|
|
/// </remarks>
|
|
/// <exception cref="ArgumentException">Thrown if `end < begin`.</exception>
|
|
/// <exception cref="ArgumentOutOfRangeException">Thrown if `begin` or `end` are out of bounds.</exception>
|
|
[Obsolete("RemoveRangeWithBeginEnd(begin, end) is deprecated, use RemoveRange(index, count) instead. (RemovedAfter 2021-06-02)", false)]
|
|
public void RemoveRangeWithBeginEnd(int begin, int end)
|
|
{
|
|
CheckBeginEnd(begin, end);
|
|
|
|
int itemsToRemove = end - begin;
|
|
if (itemsToRemove > 0)
|
|
{
|
|
int copyFrom = math.min(begin + itemsToRemove, m_length);
|
|
var sizeOf = sizeof(T);
|
|
void* dst = (byte*)Ptr + begin * sizeOf;
|
|
void* src = (byte*)Ptr + copyFrom * sizeOf;
|
|
UnsafeUtility.MemCpy(dst, src, (m_length - copyFrom) * sizeOf);
|
|
m_length -= itemsToRemove;
|
|
}
|
|
}
|
|
|
|
/// <summary>
|
|
/// Returns a parallel reader of this list.
|
|
/// </summary>
|
|
/// <returns>A parallel reader of this list.</returns>
|
|
public ParallelReader AsParallelReader()
|
|
{
|
|
return new ParallelReader(Ptr, Length);
|
|
}
|
|
|
|
/// <summary>
|
|
/// A parallel reader for an UnsafeList<T>.
|
|
/// </summary>
|
|
/// <remarks>
|
|
/// Use <see cref="AsParallelReader"/> to create a parallel reader for a list.
|
|
/// </remarks>
|
|
[BurstCompatible(GenericTypeArguments = new [] { typeof(int) })]
|
|
public unsafe struct ParallelReader
|
|
{
|
|
/// <summary>
|
|
/// The internal buffer of the list.
|
|
/// </summary>
|
|
[NativeDisableUnsafePtrRestriction]
|
|
public readonly T* Ptr;
|
|
|
|
/// <summary>
|
|
/// The number of elements.
|
|
/// </summary>
|
|
public readonly int Length;
|
|
|
|
internal ParallelReader(T* ptr, int length)
|
|
{
|
|
Ptr = ptr;
|
|
Length = length;
|
|
}
|
|
}
|
|
|
|
/// <summary>
|
|
/// Returns a parallel writer of this list.
|
|
/// </summary>
|
|
/// <returns>A parallel writer of this list.</returns>
|
|
public ParallelWriter AsParallelWriter()
|
|
{
|
|
return new ParallelWriter((UnsafeList<T>*)UnsafeUtility.AddressOf(ref this));
|
|
}
|
|
|
|
/// <summary>
|
|
/// A parallel writer for an UnsafeList<T>.
|
|
/// </summary>
|
|
/// <remarks>
|
|
/// Use <see cref="AsParallelWriter"/> to create a parallel writer for a list.
|
|
/// </remarks>
|
|
[BurstCompatible(GenericTypeArguments = new [] { typeof(int) })]
|
|
public unsafe struct ParallelWriter
|
|
{
|
|
/// <summary>
|
|
/// The data of the list.
|
|
/// </summary>
|
|
public readonly void* Ptr => ListData->Ptr;
|
|
|
|
/// <summary>
|
|
/// The UnsafeList to write to.
|
|
/// </summary>
|
|
[NativeDisableUnsafePtrRestriction]
|
|
public UnsafeList<T>* ListData;
|
|
|
|
internal unsafe ParallelWriter(UnsafeList<T>* listData)
|
|
{
|
|
ListData = listData;
|
|
}
|
|
|
|
/// <summary>
|
|
/// Adds an element to the end of the list.
|
|
/// </summary>
|
|
/// <param name="value">The value to add to the end of the list.</param>
|
|
/// <remarks>
|
|
/// Increments the length by 1. Never increases the capacity.
|
|
/// </remarks>
|
|
/// <exception cref="Exception">Thrown if incrementing the length would exceed the capacity.</exception>
|
|
[BurstCompatible(GenericTypeArguments = new[] { typeof(int) })]
|
|
public void AddNoResize(T value)
|
|
{
|
|
var idx = Interlocked.Increment(ref ListData->m_length) - 1;
|
|
ListData->CheckNoResizeHasEnoughCapacity(idx, 1);
|
|
UnsafeUtility.WriteArrayElement(ListData->Ptr, idx, value);
|
|
}
|
|
|
|
/// <summary>
|
|
/// Copies elements from a buffer to the end of the list.
|
|
/// </summary>
|
|
/// <param name="ptr">The buffer to copy from.</param>
|
|
/// <param name="count">The number of elements to copy from the buffer.</param>
|
|
/// <remarks>
|
|
/// Increments the length by `count`. Never increases the capacity.
|
|
/// </remarks>
|
|
/// <exception cref="Exception">Thrown if the increased length would exceed the capacity.</exception>
|
|
[BurstCompatible(GenericTypeArguments = new[] { typeof(int) })]
|
|
public void AddRangeNoResize(void* ptr, int count)
|
|
{
|
|
var idx = Interlocked.Add(ref ListData->m_length, count) - count;
|
|
ListData->CheckNoResizeHasEnoughCapacity(idx, count);
|
|
void* dst = (byte*)ListData->Ptr + idx * sizeof(T);
|
|
UnsafeUtility.MemCpy(dst, ptr, count * sizeof(T));
|
|
}
|
|
|
|
/// <summary>
|
|
/// Copies the elements of another list to the end of this list.
|
|
/// </summary>
|
|
/// <param name="list">The other list to copy from.</param>
|
|
/// <remarks>
|
|
/// Increments the length by the length of the other list. Never increases the capacity.
|
|
/// </remarks>
|
|
/// <exception cref="Exception">Thrown if the increased length would exceed the capacity.</exception>
|
|
[BurstCompatible(GenericTypeArguments = new[] { typeof(int) })]
|
|
public void AddRangeNoResize(UnsafeList<T> list)
|
|
{
|
|
AddRangeNoResize(list.Ptr, list.Length);
|
|
}
|
|
}
|
|
|
|
/// <summary>
|
|
/// Overwrites the elements of this list with the elements of an equal-length array.
|
|
/// </summary>
|
|
/// <param name="array">An array to copy into this list.</param>
|
|
public void CopyFrom(UnsafeList<T> array)
|
|
{
|
|
Resize(array.Length);
|
|
UnsafeUtility.MemCpy(Ptr, array.Ptr, UnsafeUtility.SizeOf<T>() * Length);
|
|
}
|
|
|
|
|
|
/// <summary>
|
|
/// Returns an enumerator over the elements of the list.
|
|
/// </summary>
|
|
/// <returns>An enumerator over the elements of the list.</returns>
|
|
public Enumerator GetEnumerator()
|
|
{
|
|
return new Enumerator { m_Ptr = Ptr, m_Length = Length, m_Index = -1 };
|
|
}
|
|
|
|
/// <summary>
|
|
/// This method is not implemented. Use <see cref="GetEnumerator"/> instead.
|
|
/// </summary>
|
|
/// <returns>Throws NotImplementedException.</returns>
|
|
/// <exception cref="NotImplementedException">Method is not implemented.</exception>
|
|
IEnumerator IEnumerable.GetEnumerator()
|
|
{
|
|
throw new NotImplementedException();
|
|
}
|
|
|
|
/// <summary>
|
|
/// This method is not implemented. Use <see cref="GetEnumerator"/> instead.
|
|
/// </summary>
|
|
/// <returns>Throws NotImplementedException.</returns>
|
|
/// <exception cref="NotImplementedException">Method is not implemented.</exception>
|
|
IEnumerator<T> IEnumerable<T>.GetEnumerator()
|
|
{
|
|
throw new NotImplementedException();
|
|
}
|
|
|
|
/// <summary>
|
|
/// An enumerator over the elements of a list.
|
|
/// </summary>
|
|
/// <remarks>
|
|
/// In an enumerator's initial state, <see cref="Current"/> is invalid.
|
|
/// The first <see cref="MoveNext"/> call advances the enumerator to the first element of the list.
|
|
/// </remarks>
|
|
public struct Enumerator : IEnumerator<T>
|
|
{
|
|
internal T* m_Ptr;
|
|
internal int m_Length;
|
|
internal int m_Index;
|
|
|
|
/// <summary>
|
|
/// Does nothing.
|
|
/// </summary>
|
|
public void Dispose() { }
|
|
|
|
/// <summary>
|
|
/// Advances the enumerator to the next element of the list.
|
|
/// </summary>
|
|
/// <remarks>
|
|
/// The first `MoveNext` call advances the enumerator to the first element of the list. Before this call, `Current` is not valid to read.
|
|
/// </remarks>
|
|
/// <returns>True if `Current` is valid to read after the call.</returns>
|
|
public bool MoveNext() => ++m_Index < m_Length;
|
|
|
|
/// <summary>
|
|
/// Resets the enumerator to its initial state.
|
|
/// </summary>
|
|
public void Reset() => m_Index = -1;
|
|
|
|
/// <summary>
|
|
/// The current element.
|
|
/// </summary>
|
|
/// <value>The current element.</value>
|
|
public T Current => m_Ptr[m_Index];
|
|
|
|
object IEnumerator.Current => Current;
|
|
}
|
|
|
|
[Conditional("ENABLE_UNITY_COLLECTIONS_CHECKS")]
|
|
internal static void CheckNull(void* listData)
|
|
{
|
|
if (listData == null)
|
|
{
|
|
throw new Exception("UnsafeList has yet to be created or has been destroyed!");
|
|
}
|
|
}
|
|
|
|
[Conditional("ENABLE_UNITY_COLLECTIONS_CHECKS")]
|
|
void CheckIndexCount(int index, int count)
|
|
{
|
|
if (count < 0)
|
|
{
|
|
throw new ArgumentOutOfRangeException($"Value for cound {count} must be positive.");
|
|
}
|
|
|
|
if (index < 0)
|
|
{
|
|
throw new ArgumentOutOfRangeException($"Value for index {index} must be positive.");
|
|
}
|
|
|
|
if (index > Length)
|
|
{
|
|
throw new ArgumentOutOfRangeException($"Value for index {index} is out of bounds.");
|
|
}
|
|
|
|
if (index+count > Length)
|
|
{
|
|
throw new ArgumentOutOfRangeException($"Value for count {count} is out of bounds.");
|
|
}
|
|
}
|
|
|
|
[Conditional("ENABLE_UNITY_COLLECTIONS_CHECKS")]
|
|
void CheckBeginEnd(int begin, int end)
|
|
{
|
|
if (begin > end)
|
|
{
|
|
throw new ArgumentException($"Value for begin {begin} index must less or equal to end {end}.");
|
|
}
|
|
|
|
if (begin < 0)
|
|
{
|
|
throw new ArgumentOutOfRangeException($"Value for begin {begin} must be positive.");
|
|
}
|
|
|
|
if (begin > Length)
|
|
{
|
|
throw new ArgumentOutOfRangeException($"Value for begin {begin} is out of bounds.");
|
|
}
|
|
|
|
if (end > Length)
|
|
{
|
|
throw new ArgumentOutOfRangeException($"Value for end {end} is out of bounds.");
|
|
}
|
|
}
|
|
|
|
[Conditional("ENABLE_UNITY_COLLECTIONS_CHECKS")]
|
|
void CheckNoResizeHasEnoughCapacity(int length)
|
|
{
|
|
CheckNoResizeHasEnoughCapacity(length, Length);
|
|
}
|
|
|
|
[Conditional("ENABLE_UNITY_COLLECTIONS_CHECKS")]
|
|
void CheckNoResizeHasEnoughCapacity(int length, int index)
|
|
{
|
|
if (Capacity < index + length)
|
|
{
|
|
throw new Exception($"AddNoResize assumes that list capacity is sufficient (Capacity {Capacity}, Length {Length}), requested length {length}!");
|
|
}
|
|
}
|
|
}
|
|
|
|
/// <summary>
|
|
/// Provides extension methods for UnsafeList.
|
|
/// </summary>
|
|
[BurstCompatible]
|
|
public unsafe static class UnsafeListExtensions
|
|
{
|
|
/// <summary>
|
|
/// Finds the index of the first occurrence of a particular value in this list.
|
|
/// </summary>
|
|
/// <typeparam name="T">The type of elements in this list.</typeparam>
|
|
/// <typeparam name="U">The type of value to locate.</typeparam>
|
|
/// <param name="list">This list.</param>
|
|
/// <param name="value">A value to locate.</param>
|
|
/// <returns>The zero-based index of the first occurrence of the value if it is found. Returns -1 if no occurrence is found.</returns>
|
|
[BurstCompatible(GenericTypeArguments = new [] { typeof(int), typeof(int) })]
|
|
public static int IndexOf<T, U>(this UnsafeList<T> list, U value) where T : unmanaged, IEquatable<U>
|
|
{
|
|
return NativeArrayExtensions.IndexOf<T, U>(list.Ptr, list.Length, value);
|
|
}
|
|
|
|
/// <summary>
|
|
/// Returns true if a particular value is present in this list.
|
|
/// </summary>
|
|
/// <typeparam name="T">The type of elements in the list.</typeparam>
|
|
/// <typeparam name="U">The type of value to locate.</typeparam>
|
|
/// <param name="list">This list.</param>
|
|
/// <param name="value">The value to locate.</param>
|
|
/// <returns>True if the value is present in this list.</returns>
|
|
[BurstCompatible(GenericTypeArguments = new [] { typeof(int), typeof(int) })]
|
|
public static bool Contains<T, U>(this UnsafeList<T> list, U value) where T : unmanaged, IEquatable<U>
|
|
{
|
|
return list.IndexOf(value) != -1;
|
|
}
|
|
|
|
/// <summary>
|
|
/// Finds the index of the first occurrence of a particular value in the list.
|
|
/// </summary>
|
|
/// <typeparam name="T">The type of elements in the list.</typeparam>
|
|
/// <typeparam name="U">The type of value to locate.</typeparam>
|
|
/// <param name="list">This reader of the list.</param>
|
|
/// <param name="value">A value to locate.</param>
|
|
/// <returns>The zero-based index of the first occurrence of the value if it is found. Returns -1 if no occurrence is found.</returns>
|
|
[BurstCompatible(GenericTypeArguments = new [] { typeof(int), typeof(int) })]
|
|
public static int IndexOf<T, U>(this UnsafeList<T>.ParallelReader list, U value) where T : unmanaged, IEquatable<U>
|
|
{
|
|
return NativeArrayExtensions.IndexOf<T, U>(list.Ptr, list.Length, value);
|
|
}
|
|
|
|
/// <summary>
|
|
/// Returns true if a particular value is present in the list.
|
|
/// </summary>
|
|
/// <typeparam name="T">The type of elements in the list.</typeparam>
|
|
/// <typeparam name="U">The type of value to locate.</typeparam>
|
|
/// <param name="list">This reader of the list.</param>
|
|
/// <param name="value">The value to locate.</param>
|
|
/// <returns>True if the value is present in the list.</returns>
|
|
[BurstCompatible(GenericTypeArguments = new [] { typeof(int), typeof(int) })]
|
|
public static bool Contains<T, U>(this UnsafeList<T>.ParallelReader list, U value) where T : unmanaged, IEquatable<U>
|
|
{
|
|
return list.IndexOf(value) != -1;
|
|
}
|
|
|
|
|
|
/// <summary>
|
|
/// Returns true if this array and another have equal length and content.
|
|
/// </summary>
|
|
/// <typeparam name="T">The type of the source array's elements.</typeparam>
|
|
/// <param name="array">The array to compare for equality.</param>
|
|
/// <param name="other">The other array to compare for equality.</param>
|
|
/// <returns>True if the arrays have equal length and content.</returns>
|
|
[BurstCompatible(GenericTypeArguments = new [] { typeof(int) })]
|
|
public static bool ArraysEqual<T>(this UnsafeList<T> array, UnsafeList<T> other) where T : unmanaged, IEquatable<T>
|
|
{
|
|
if (array.Length != other.Length)
|
|
return false;
|
|
|
|
for (int i = 0; i != array.Length; i++)
|
|
{
|
|
if (!array[i].Equals(other[i]))
|
|
return false;
|
|
}
|
|
|
|
return true;
|
|
}
|
|
|
|
}
|
|
|
|
internal sealed class UnsafeListTDebugView<T>
|
|
where T : unmanaged
|
|
{
|
|
UnsafeList<T> Data;
|
|
|
|
public UnsafeListTDebugView(UnsafeList<T> data)
|
|
{
|
|
Data = data;
|
|
}
|
|
|
|
public unsafe T[] Items
|
|
{
|
|
get
|
|
{
|
|
T[] result = new T[Data.Length];
|
|
|
|
for (var i = 0; i < result.Length; ++i)
|
|
{
|
|
result[i] = Data.Ptr[i];
|
|
}
|
|
|
|
return result;
|
|
}
|
|
}
|
|
}
|
|
|
|
/// <summary>
|
|
/// An unmanaged, resizable list of pointers.
|
|
/// </summary>
|
|
/// <typeparam name="T">The type of pointer element.</typeparam>
|
|
[DebuggerDisplay("Length = {Length}, Capacity = {Capacity}, IsCreated = {IsCreated}, IsEmpty = {IsEmpty}")]
|
|
[DebuggerTypeProxy(typeof(UnsafePtrListTDebugView<>))]
|
|
[StructLayout(LayoutKind.Sequential)]
|
|
[BurstCompatible(GenericTypeArguments = new[] { typeof(int) })]
|
|
public unsafe struct UnsafePtrList<T>
|
|
: INativeDisposable
|
|
// IIndexable<T> and INativeList<T> can't be implemented because this[index] and ElementAt return T* instead of T.
|
|
, IEnumerable<IntPtr> // Used by collection initializers.
|
|
where T : unmanaged
|
|
{
|
|
/// <summary>
|
|
/// The internal buffer of this list.
|
|
/// </summary>
|
|
[NativeDisableUnsafePtrRestriction]
|
|
public readonly T** Ptr;
|
|
|
|
/// <summary>
|
|
/// The number of elements.
|
|
/// </summary>
|
|
public readonly int m_length;
|
|
|
|
/// <summary>
|
|
/// The number of elements that can fit in the internal buffer.
|
|
/// </summary>
|
|
public readonly int m_capacity;
|
|
|
|
/// <summary>
|
|
/// The allocator used to create the internal buffer.
|
|
/// </summary>
|
|
public readonly AllocatorManager.AllocatorHandle Allocator;
|
|
|
|
[Obsolete("Use Length property (UnityUpgradable) -> Length", true)]
|
|
public int length;
|
|
|
|
[Obsolete("Use Capacity property (UnityUpgradable) -> Capacity", true)]
|
|
public int capacity;
|
|
|
|
/// <summary>
|
|
/// The number of elements.
|
|
/// </summary>
|
|
/// <value>The number of elements.</value>
|
|
public int Length
|
|
{
|
|
get
|
|
{
|
|
return this.ListData().Length;
|
|
}
|
|
|
|
set
|
|
{
|
|
this.ListData().Length = value;
|
|
}
|
|
}
|
|
|
|
/// <summary>
|
|
/// The number of elements that can fit in the internal buffer.
|
|
/// </summary>
|
|
/// <value>The number of elements that can fit in the internal buffer.</value>
|
|
public int Capacity
|
|
{
|
|
get
|
|
{
|
|
return this.ListData().Capacity;
|
|
}
|
|
|
|
set
|
|
{
|
|
this.ListData().Capacity = value;
|
|
}
|
|
}
|
|
|
|
/// <summary>
|
|
/// The element at an index.
|
|
/// </summary>
|
|
/// <param name="index">An index.</param>
|
|
/// <value>The element at the index.</value>
|
|
public T* this[int index]
|
|
{
|
|
get
|
|
{
|
|
CollectionHelper.CheckIndexInRange(index, Length);
|
|
return Ptr[CollectionHelper.AssumePositive(index)];
|
|
}
|
|
|
|
set
|
|
{
|
|
CollectionHelper.CheckIndexInRange(index, Length);
|
|
Ptr[CollectionHelper.AssumePositive(index)] = value;
|
|
}
|
|
}
|
|
|
|
/// <summary>
|
|
/// Returns a reference to the element at a given index.
|
|
/// </summary>
|
|
/// <param name="index">The index to access. Must be in the range of [0..Length).</param>
|
|
/// <returns>A reference to the element at the index.</returns>
|
|
public ref T* ElementAt(int index)
|
|
{
|
|
CollectionHelper.CheckIndexInRange(index, Length);
|
|
return ref Ptr[CollectionHelper.AssumePositive(index)];
|
|
}
|
|
|
|
/// <summary>
|
|
/// Initializes and returns an instance of UnsafePtrList.
|
|
/// </summary>
|
|
/// <param name="ptr">An existing pointer array to set as the internal buffer.</param>
|
|
/// <param name="length">The length.</param>
|
|
public unsafe UnsafePtrList(T** ptr, int length) : this()
|
|
{
|
|
Ptr = ptr;
|
|
this.m_length = length;
|
|
this.m_capacity = length;
|
|
Allocator = AllocatorManager.None;
|
|
}
|
|
|
|
/// <summary>
|
|
/// Initializes and returns an instance of UnsafePtrList.
|
|
/// </summary>
|
|
/// <param name="initialCapacity">The initial capacity of the list.</param>
|
|
/// <param name="allocator">The allocator to use.</param>
|
|
/// <param name="options">Whether newly allocated bytes should be zeroed out.</param>
|
|
public unsafe UnsafePtrList(int initialCapacity, AllocatorManager.AllocatorHandle allocator, NativeArrayOptions options = NativeArrayOptions.UninitializedMemory) : this()
|
|
{
|
|
Ptr = null;
|
|
m_length = 0;
|
|
m_capacity = 0;
|
|
Allocator = AllocatorManager.None;
|
|
|
|
this.ListData() = new UnsafeList<IntPtr>(initialCapacity, allocator, options);
|
|
}
|
|
|
|
/// <summary>
|
|
/// Returns a new list of pointers.
|
|
/// </summary>
|
|
/// <param name="ptr">An existing pointer array to set as the internal buffer.</param>
|
|
/// <param name="length">The length.</param>
|
|
/// <returns>A pointer to the new list.</returns>
|
|
public static UnsafePtrList<T>* Create(T** ptr, int length)
|
|
{
|
|
UnsafePtrList<T>* listData = AllocatorManager.Allocate<UnsafePtrList<T>>(AllocatorManager.Persistent);
|
|
*listData = new UnsafePtrList<T>(ptr, length);
|
|
return listData;
|
|
}
|
|
|
|
/// <summary>
|
|
/// Returns a new list of pointers.
|
|
/// </summary>
|
|
/// <param name="initialCapacity">The initial capacity of the list.</param>
|
|
/// <param name="allocator">The allocator to use.</param>
|
|
/// <param name="options">Whether newly allocated bytes should be zeroed out.</param>
|
|
/// <returns>A pointer to the new list.</returns>
|
|
public static UnsafePtrList<T>* Create(int initialCapacity, AllocatorManager.AllocatorHandle allocator, NativeArrayOptions options = NativeArrayOptions.UninitializedMemory)
|
|
{
|
|
UnsafePtrList<T>* listData = AllocatorManager.Allocate<UnsafePtrList<T>>(allocator);
|
|
*listData = new UnsafePtrList<T>(initialCapacity, allocator, options);
|
|
return listData;
|
|
}
|
|
|
|
/// <summary>
|
|
/// Destroys the list.
|
|
/// </summary>
|
|
/// <param name="listData">The list to destroy.</param>
|
|
public static void Destroy(UnsafePtrList<T>* listData)
|
|
{
|
|
UnsafeList<IntPtr>.CheckNull(listData);
|
|
var allocator = listData->ListData().Allocator.Value == AllocatorManager.Invalid.Value
|
|
? AllocatorManager.Persistent
|
|
: listData->ListData().Allocator
|
|
;
|
|
listData->Dispose();
|
|
AllocatorManager.Free(allocator, listData);
|
|
}
|
|
|
|
/// <summary>
|
|
/// Whether the list is empty.
|
|
/// </summary>
|
|
/// <value>True if the list is empty or the list has not been constructed.</value>
|
|
public bool IsEmpty => !IsCreated || Length == 0;
|
|
|
|
/// <summary>
|
|
/// Whether this list has been allocated (and not yet deallocated).
|
|
/// </summary>
|
|
/// <value>True if this list has been allocated (and not yet deallocated).</value>
|
|
public bool IsCreated => Ptr != null;
|
|
|
|
/// <summary>
|
|
/// Releases all resources (memory).
|
|
/// </summary>
|
|
public void Dispose()
|
|
{
|
|
this.ListData().Dispose();
|
|
}
|
|
|
|
/// <summary>
|
|
/// Creates and schedules a job that frees the memory of this list.
|
|
/// </summary>
|
|
/// <param name="inputDeps">The dependency for the new job.</param>
|
|
/// <returns>The handle of the new job. The job depends upon `inputDeps` and frees the memory of this list.</returns>
|
|
[NotBurstCompatible /* This is not burst compatible because of IJob's use of a static IntPtr. Should switch to IJobBurstSchedulable in the future */]
|
|
public JobHandle Dispose(JobHandle inputDeps) => this.ListData().Dispose(inputDeps);
|
|
|
|
/// <summary>
|
|
/// Sets the length to 0.
|
|
/// </summary>
|
|
/// <remarks>Does not change the capacity.</remarks>
|
|
public void Clear() => this.ListData().Clear();
|
|
|
|
/// <summary>
|
|
/// Sets the length, expanding the capacity if necessary.
|
|
/// </summary>
|
|
/// <param name="length">The new length.</param>
|
|
/// <param name="options">Whether newly allocated bytes should be zeroed out.</param>
|
|
public void Resize(int length, NativeArrayOptions options = NativeArrayOptions.UninitializedMemory) => this.ListData().Resize(length, options);
|
|
|
|
/// <summary>
|
|
/// Sets the capacity.
|
|
/// </summary>
|
|
/// <param name="capacity">The new capacity.</param>
|
|
public void SetCapacity(int capacity) => this.ListData().SetCapacity(capacity);
|
|
|
|
/// <summary>
|
|
/// Sets the capacity to match the length.
|
|
/// </summary>
|
|
public void TrimExcess() => this.ListData().TrimExcess();
|
|
|
|
/// <summary>
|
|
/// Returns the index of the first occurrence of a specific pointer in the list.
|
|
/// </summary>
|
|
/// <param name="ptr">The pointer to search for in the list.</param>
|
|
/// <returns>The index of the first occurrence of the pointer. Returns -1 if it is not found in the list.</returns>
|
|
public int IndexOf(void* ptr)
|
|
{
|
|
for (int i = 0; i < Length; ++i)
|
|
{
|
|
if (Ptr[i] == ptr) return i;
|
|
}
|
|
|
|
return -1;
|
|
}
|
|
|
|
/// <summary>
|
|
/// Returns true if the list contains at least one occurrence of a specific pointer.
|
|
/// </summary>
|
|
/// <param name="ptr">The pointer to search for in the list.</param>
|
|
/// <returns>True if the list contains at least one occurrence of the pointer.</returns>
|
|
public bool Contains(void* ptr)
|
|
{
|
|
return IndexOf(ptr) != -1;
|
|
}
|
|
|
|
/// <summary>
|
|
/// Adds a pointer to the end of this list.
|
|
/// </summary>
|
|
/// <remarks>
|
|
/// Increments the length by 1. Never increases the capacity.
|
|
/// </remarks>
|
|
/// <param name="value">The pointer to add to the end of the list.</param>
|
|
/// <exception cref="Exception">Thrown if incrementing the length would exceed the capacity.</exception>
|
|
public void AddNoResize(void* value)
|
|
{
|
|
this.ListData().AddNoResize((IntPtr)value);
|
|
}
|
|
|
|
/// <summary>
|
|
/// Copies pointers from a buffer to the end of this list.
|
|
/// </summary>
|
|
/// <remarks>
|
|
/// Increments the length by `count`. Never increases the capacity.
|
|
/// </remarks>
|
|
/// <param name="ptr">The buffer to copy from.</param>
|
|
/// <param name="count">The number of pointers to copy from the buffer.</param>
|
|
/// <exception cref="Exception">Thrown if the increased length would exceed the capacity.</exception>
|
|
public void AddRangeNoResize(void** ptr, int count) => this.ListData().AddRangeNoResize(ptr, count);
|
|
|
|
/// <summary>
|
|
/// Copies the pointers of another list to the end of this list.
|
|
/// </summary>
|
|
/// <param name="list">The other list to copy from.</param>
|
|
/// <remarks>
|
|
/// Increments the length by the length of the other list. Never increases the capacity.
|
|
/// </remarks>
|
|
/// <exception cref="Exception">Thrown if the increased length would exceed the capacity.</exception>
|
|
public void AddRangeNoResize(UnsafePtrList<T> list) => this.ListData().AddRangeNoResize(list.Ptr, list.Length);
|
|
|
|
/// <summary>
|
|
/// Adds a pointer to the end of the list.
|
|
/// </summary>
|
|
/// <param name="value">The pointer to add to the end of this list.</param>
|
|
/// <remarks>
|
|
/// Increments the length by 1. Increases the capacity if necessary.
|
|
/// </remarks>
|
|
public void Add(in IntPtr value)
|
|
{
|
|
this.ListData().Add(value);
|
|
}
|
|
|
|
/// <summary>
|
|
/// Adds a pointer to the end of the list.
|
|
/// </summary>
|
|
/// <param name="value">The pointer to add to the end of this list.</param>
|
|
/// <remarks>
|
|
/// Increments the length by 1. Increases the capacity if necessary.
|
|
/// </remarks>
|
|
public void Add(void* value)
|
|
{
|
|
this.ListData().Add((IntPtr)value);
|
|
}
|
|
|
|
/// <summary>
|
|
/// Adds elements from a buffer to this list.
|
|
/// </summary>
|
|
/// <param name="ptr">A pointer to the buffer.</param>
|
|
/// <param name="length">The number of elements to add to the list.</param>
|
|
public void AddRange(void* ptr, int length) => this.ListData().AddRange(ptr, length);
|
|
|
|
/// <summary>
|
|
/// Copies the elements of another list to the end of this list.
|
|
/// </summary>
|
|
/// <param name="list">The other list to copy from.</param>
|
|
/// <remarks>
|
|
/// Increments the length by the length of the other list. Increases the capacity if necessary.
|
|
/// </remarks>
|
|
public void AddRange(UnsafePtrList<T> list) => this.ListData().AddRange(list.ListData());
|
|
|
|
/// <summary>
|
|
/// Shifts pointers toward the end of this list, increasing its length.
|
|
/// </summary>
|
|
/// <remarks>
|
|
/// Right-shifts pointers in the list so as to create 'free' slots at the beginning or in the middle.
|
|
///
|
|
/// The length is increased by `end - begin`. If necessary, the capacity will be increased accordingly.
|
|
///
|
|
/// If `end` equals `begin`, the method does nothing.
|
|
///
|
|
/// The pointer at index `begin` will be copied to index `end`, the pointer at index `begin + 1` will be copied to `end + 1`, and so forth.
|
|
///
|
|
/// The indexes `begin` up to `end` are not cleared: they will contain whatever pointers they held prior.
|
|
/// </remarks>
|
|
/// <param name="begin">The index of the first pointer that will be shifted up.</param>
|
|
/// <param name="end">The index where the first shifted pointer will end up.</param>
|
|
/// <exception cref="ArgumentException">Thrown if `end < begin`.</exception>
|
|
/// <exception cref="ArgumentOutOfRangeException">Thrown if `begin` or `end` are out of bounds.</exception>
|
|
public void InsertRangeWithBeginEnd(int begin, int end) => this.ListData().InsertRangeWithBeginEnd(begin, end);
|
|
|
|
/// <summary>
|
|
/// Copies the last pointer of this list to the specified index. Decrements the length by 1.
|
|
/// </summary>
|
|
/// <remarks>Useful as a cheap way to remove a pointer from this list when you don't care about preserving order.</remarks>
|
|
/// <param name="index">The index to overwrite with the last pointer.</param>
|
|
/// <exception cref="IndexOutOfRangeException">Thrown if `index` is out of bounds.</exception>
|
|
public void RemoveAtSwapBack(int index) => this.ListData().RemoveAtSwapBack(index);
|
|
|
|
/// <summary>
|
|
/// Copies the last *N* pointer of this list to a range in this list. Decrements the length by *N*.
|
|
/// </summary>
|
|
/// <remarks>
|
|
/// Copies the last `count` pointers to the indexes `index` up to `index + count`.
|
|
///
|
|
/// Useful as a cheap way to remove pointers from a list when you don't care about preserving order.
|
|
/// </remarks>
|
|
/// <param name="index">The index of the first pointer to overwrite.</param>
|
|
/// <param name="count">The number of pointers to copy and remove.</param>
|
|
/// <exception cref="ArgumentOutOfRangeException">Thrown if `index` is out of bounds, `count` is negative,
|
|
/// or `index + count` exceeds the length.</exception>
|
|
public void RemoveRangeSwapBack(int index, int count) => this.ListData().RemoveRangeSwapBack(index, count);
|
|
|
|
/// <summary>
|
|
/// Copies the last *N* pointers of this list to a range in this list. Decrements the length by *N*.
|
|
/// </summary>
|
|
/// <remarks>
|
|
/// Copies the last `end - begin` pointers to the indexes `begin` up to `end`.
|
|
///
|
|
/// Useful as a cheap way to remove pointers from a list when you don't care about preserving order.
|
|
///
|
|
/// Does nothing if `end - begin` is less than 1.
|
|
/// </remarks>
|
|
/// <param name="begin">The index of the first pointers to overwrite.</param>
|
|
/// <param name="end">The index one greater than the last pointers to overwrite.</param>
|
|
/// <exception cref="ArgumentOutOfRangeException">Thrown if `begin` or `end` are out of bounds.</exception>
|
|
[Obsolete("RemoveRangeSwapBackWithBeginEnd(begin, end) is deprecated, use RemoveRangeSwapBack(index, count) instead. (RemovedAfter 2021-06-02)", false)]
|
|
public void RemoveRangeSwapBackWithBeginEnd(int begin, int end) => this.ListData().RemoveRangeSwapBackWithBeginEnd(begin, end);
|
|
|
|
/// <summary>
|
|
/// Removes the pointer at an index, shifting everything above it down by one. Decrements the length by 1.
|
|
/// </summary>
|
|
/// <param name="index">The index of the pointer to remove.</param>
|
|
/// <remarks>
|
|
/// If you don't care about preserving the order of the pointers, <see cref="RemoveAtSwapBack(int)"/> is a more efficient way to remove pointers.
|
|
/// </remarks>
|
|
/// <exception cref="ArgumentOutOfRangeException">Thrown if `index` is out of bounds.</exception>
|
|
public void RemoveAt(int index) => this.ListData().RemoveAt(index);
|
|
|
|
/// <summary>
|
|
/// Removes *N* pointers in a range, shifting everything above the range down by *N*. Decrements the length by *N*.
|
|
/// </summary>
|
|
/// <param name="index">The index of the first pointer to remove.</param>
|
|
/// <param name="count">The number of pointers to remove.</param>
|
|
/// <remarks>
|
|
/// If you don't care about preserving the order of the pointers, <see cref="RemoveRangeSwapBackWithBeginEnd"/>
|
|
/// is a more efficient way to remove pointers.
|
|
/// </remarks>
|
|
/// <exception cref="ArgumentOutOfRangeException">Thrown if `index` is out of bounds, `count` is negative,
|
|
/// or `index + count` exceeds the length.</exception>
|
|
public void RemoveRange(int index, int count) => this.ListData().RemoveRange(index, count);
|
|
|
|
/// <summary>
|
|
/// Removes *N* pointers in a range, shifting everything above it down by *N*. Decrements the length by *N*.
|
|
/// </summary>
|
|
/// <param name="begin">The index of the first pointer to remove.</param>
|
|
/// <param name="end">The index one greater than the last pointer to remove.</param>
|
|
/// <remarks>
|
|
/// If you don't care about preserving the order of the pointers, <see cref="RemoveRangeSwapBackWithBeginEnd"/> is a more efficient way to remove pointers.
|
|
/// </remarks>
|
|
/// <exception cref="ArgumentException">Thrown if `end < begin`.</exception>
|
|
/// <exception cref="ArgumentOutOfRangeException">Thrown if `begin` or `end` are out of bounds.</exception>
|
|
[Obsolete("RemoveRangeWithBeginEnd(begin, end) is deprecated, use RemoveRange(index, count) instead. (RemovedAfter 2021-06-02)", false)]
|
|
public void RemoveRangeWithBeginEnd(int begin, int end) => this.ListData().RemoveRangeWithBeginEnd(begin, end);
|
|
|
|
/// <summary>
|
|
/// This method is not implemented. It will throw NotImplementedException if it is used.
|
|
/// </summary>
|
|
/// <remarks>Use Enumerator GetEnumerator() instead.</remarks>
|
|
/// <returns>Throws NotImplementedException.</returns>
|
|
/// <exception cref="NotImplementedException">Method is not implemented.</exception>
|
|
IEnumerator IEnumerable.GetEnumerator()
|
|
{
|
|
throw new NotImplementedException();
|
|
}
|
|
|
|
/// <summary>
|
|
/// This method is not implemented. It will throw NotImplementedException if it is used.
|
|
/// </summary>
|
|
/// <remarks>Use Enumerator GetEnumerator() instead.</remarks>
|
|
/// <returns>Throws NotImplementedException.</returns>
|
|
/// <exception cref="NotImplementedException">Method is not implemented.</exception>
|
|
IEnumerator<IntPtr> IEnumerable<IntPtr>.GetEnumerator()
|
|
{
|
|
throw new NotImplementedException();
|
|
}
|
|
|
|
/// <summary>
|
|
/// Returns a parallel reader of this list.
|
|
/// </summary>
|
|
/// <returns>A parallel reader of this list.</returns>
|
|
public ParallelReader AsParallelReader()
|
|
{
|
|
return new ParallelReader(Ptr, Length);
|
|
}
|
|
|
|
/// <summary>
|
|
/// A parallel reader for an UnsafePtrList<T>.
|
|
/// </summary>
|
|
/// <remarks>
|
|
/// Use <see cref="AsParallelReader"/> to create a parallel reader for a list.
|
|
/// </remarks>
|
|
[BurstCompatible(GenericTypeArguments = new[] { typeof(int) })]
|
|
public unsafe struct ParallelReader
|
|
{
|
|
/// <summary>
|
|
/// The internal buffer of the list.
|
|
/// </summary>
|
|
[NativeDisableUnsafePtrRestriction]
|
|
public readonly T** Ptr;
|
|
|
|
/// <summary>
|
|
/// The number of elements.
|
|
/// </summary>
|
|
public readonly int Length;
|
|
|
|
internal ParallelReader(T** ptr, int length)
|
|
{
|
|
Ptr = ptr;
|
|
Length = length;
|
|
}
|
|
|
|
/// <summary>
|
|
/// Returns the index of the first occurrence of a specific pointer in the list.
|
|
/// </summary>
|
|
/// <param name="ptr">The pointer to search for in the list.</param>
|
|
/// <returns>The index of the first occurrence of the pointer. Returns -1 if it is not found in the list.</returns>
|
|
public int IndexOf(void* ptr)
|
|
{
|
|
for (int i = 0; i < Length; ++i)
|
|
{
|
|
if (Ptr[i] == ptr) return i;
|
|
}
|
|
return -1;
|
|
}
|
|
|
|
/// <summary>
|
|
/// Returns true if the list contains at least one occurrence of a specific pointer.
|
|
/// </summary>
|
|
/// <param name="ptr">The pointer to search for in the list.</param>
|
|
/// <returns>True if the list contains at least one occurrence of the pointer.</returns>
|
|
public bool Contains(void* ptr)
|
|
{
|
|
return IndexOf(ptr) != -1;
|
|
}
|
|
}
|
|
|
|
/// <summary>
|
|
/// Returns a parallel writer of this list.
|
|
/// </summary>
|
|
/// <returns>A parallel writer of this list.</returns>
|
|
public ParallelWriter AsParallelWriter()
|
|
{
|
|
return new ParallelWriter(Ptr, (UnsafeList<IntPtr>*)UnsafeUtility.AddressOf(ref this));
|
|
}
|
|
|
|
/// <summary>
|
|
/// A parallel writer for an UnsafePtrList<T>.
|
|
/// </summary>
|
|
/// <remarks>
|
|
/// Use <see cref="AsParallelWriter"/> to create a parallel writer for a list.
|
|
/// </remarks>
|
|
[BurstCompatible(GenericTypeArguments = new[] { typeof(int) })]
|
|
public unsafe struct ParallelWriter
|
|
{
|
|
/// <summary>
|
|
/// The data of the list.
|
|
/// </summary>
|
|
[NativeDisableUnsafePtrRestriction]
|
|
public readonly T** Ptr;
|
|
|
|
/// <summary>
|
|
/// The UnsafeList to write to.
|
|
/// </summary>
|
|
[NativeDisableUnsafePtrRestriction]
|
|
public UnsafeList<IntPtr>* ListData;
|
|
|
|
internal unsafe ParallelWriter(T** ptr, UnsafeList<IntPtr>* listData)
|
|
{
|
|
Ptr = ptr;
|
|
ListData = listData;
|
|
}
|
|
|
|
/// <summary>
|
|
/// Adds a pointer to the end of the list.
|
|
/// </summary>
|
|
/// <param name="value">The pointer to add to the end of the list.</param>
|
|
/// <remarks>
|
|
/// Increments the length by 1. Never increases the capacity.
|
|
/// </remarks>
|
|
/// <exception cref="Exception">Thrown if incrementing the length would exceed the capacity.</exception>
|
|
public void AddNoResize(T* value) => ListData->AddNoResize((IntPtr)value);
|
|
|
|
/// <summary>
|
|
/// Copies pointers from a buffer to the end of the list.
|
|
/// </summary>
|
|
/// <param name="ptr">The buffer to copy from.</param>
|
|
/// <param name="count">The number of pointers to copy from the buffer.</param>
|
|
/// <remarks>
|
|
/// Increments the length by `count`. Never increases the capacity.
|
|
/// </remarks>
|
|
/// <exception cref="Exception">Thrown if the increased length would exceed the capacity.</exception>
|
|
public void AddRangeNoResize(T** ptr, int count) => ListData->AddRangeNoResize(ptr, count);
|
|
|
|
/// <summary>
|
|
/// Copies the pointers of another list to the end of this list.
|
|
/// </summary>
|
|
/// <param name="list">The other list to copy from.</param>
|
|
/// <remarks>
|
|
/// Increments the length by the length of the other list. Never increases the capacity.
|
|
/// </remarks>
|
|
/// <exception cref="Exception">Thrown if the increased length would exceed the capacity.</exception>
|
|
public void AddRangeNoResize(UnsafePtrList<T> list) => ListData->AddRangeNoResize(list.Ptr, list.Length);
|
|
}
|
|
}
|
|
|
|
[BurstCompatible]
|
|
internal static class UnsafePtrListTExtensions
|
|
{
|
|
[BurstCompatible(GenericTypeArguments = new[] { typeof(int) })]
|
|
public static ref UnsafeList<IntPtr> ListData<T>(ref this UnsafePtrList<T> from) where T : unmanaged => ref UnsafeUtility.As<UnsafePtrList<T>, UnsafeList<IntPtr>>(ref from);
|
|
}
|
|
|
|
internal sealed class UnsafePtrListTDebugView<T>
|
|
where T : unmanaged
|
|
{
|
|
UnsafePtrList<T> Data;
|
|
|
|
public UnsafePtrListTDebugView(UnsafePtrList<T> data)
|
|
{
|
|
Data = data;
|
|
}
|
|
|
|
public unsafe T*[] Items
|
|
{
|
|
get
|
|
{
|
|
T*[] result = new T*[Data.Length];
|
|
|
|
for (var i = 0; i < result.Length; ++i)
|
|
{
|
|
result[i] = Data.Ptr[i];
|
|
}
|
|
|
|
return result;
|
|
}
|
|
}
|
|
}
|
|
}
|