internal void ClearChildren()
{
#if ENABLE_UNITY_COLLECTIONS_CHECKS
AtomicSafetyHandle.CheckWriteAndBumpSecondaryVersion(m_Safety);
#endif
m_Array->ClearChildren();
}
public void AddRange(NativeArray <T> elements)
{
#if ENABLE_UNITY_COLLECTIONS_CHECKS
AtomicSafetyHandle.CheckWriteAndBumpSecondaryVersion(m_Safety);
#endif
AddRange(elements.GetUnsafeReadOnlyPtr(), elements.Length);
}
public void Add(T element)
{
#if ENABLE_UNITY_COLLECTIONS_CHECKS
AtomicSafetyHandle.CheckWriteAndBumpSecondaryVersion(m_Safety);
#endif
m_Impl.Add(element);
}
public unsafe int AllocateItemAndAddValues(NativeArray <T> other, int otherLength)
{
CheckArgInRangeInc(otherLength, other.Length);
#if ENABLE_UNITY_COLLECTIONS_CHECKS
AtomicSafetyHandle.CheckWriteAndBumpSecondaryVersion(m_Safety);
#endif
var index = m_Array->AllocateItem();
var ptr = m_Array->Ptr[index];
var capacity = Math.Max(1, otherLength);
m_Array->InitializeIndex(index, UnsafeUtility.SizeOf <T>(), UnsafeUtility.AlignOf <T>(), capacity);
#if ENABLE_UNITY_COLLECTIONS_CHECKS
CheckAllocated(m_Array->Ptr[index]);
#endif
if (otherLength > 0)
{
#if ENABLE_UNITY_COLLECTIONS_CHECKS
var dstList = new NativeList(m_Array->Ptr[index], ref m_Safety);
#else
var dstList = new NativeList(m_Array->Ptr[index]);
#endif
dstList.AddRangeNoResize(other, otherLength);
}
Debug.Assert(IsAllocated(index));
return(index);
}
public void RemoveRangeAtSwapBack(int index, int length)
{
#if ENABLE_UNITY_COLLECTIONS_CHECKS
AtomicSafetyHandle.CheckWriteAndBumpSecondaryVersion(m_Safety);
if (index < 0 || index >= Length)
{
throw new ArgumentOutOfRangeException(index.ToString());
}
#endif
int need_swap = m_ListData->length - index - length;
if (need_swap > length)
{
need_swap = length;
}
if (need_swap > 0)
{
var sizeOf = UnsafeUtility.SizeOf <T>();
int p_end_index = m_ListData->length - need_swap;
UnsafeUtility.MemCpy((byte *)m_ListData->buffer + index * sizeOf,
(byte *)m_ListData->buffer + p_end_index * sizeOf, sizeOf * need_swap);
m_ListData->length = m_ListData->length - length;
}
else
{
m_ListData->length = index;
}
}
public NativeList SafeGet(int index)
{
#if ENABLE_UNITY_COLLECTIONS_CHECKS
AtomicSafetyHandle.CheckWriteAndBumpSecondaryVersion(m_Safety);
#endif
#if ENABLE_UNITY_COLLECTIONS_CHECKS
AtomicSafetyHandle.CheckReadAndThrow(m_Safety);
#endif
CheckArgPositive(index);
var positiveIndex = AssumePositive(index);
CheckArgInRange(positiveIndex, m_Array->Length);
var ptr = m_Array->Ptr[positiveIndex];
#if ENABLE_UNITY_COLLECTIONS_CHECKS
if (ptr == null ||
!ptr->IsCreated)
{
return(new NativeList(null, ref m_Safety));
}
return(new NativeList(m_Array->Ptr[positiveIndex], ref m_Safety));
#else
if (ptr == null ||
!ptr->IsCreated)
{
return(new NativeList(null));
}
return(new NativeList(m_Array->Ptr[positiveIndex]));
#endif
}
public int AllocateItemAndAddValues(NativeListArray <T> .NativeList other)
{
#if ENABLE_UNITY_COLLECTIONS_CHECKS
AtomicSafetyHandle.CheckWriteAndBumpSecondaryVersion(m_Safety);
#endif
var index = m_Array->AllocateItem();
var ptr = m_Array->Ptr[index];
if (ptr == null || !ptr->IsCreated)
{
m_Array->InitializeIndex(index, UnsafeUtility.SizeOf <T>(), UnsafeUtility.AlignOf <T>(), other.Length);
}
else
{
ptr->Clear();
if (ptr->Capacity < other.Length)
{
ptr->SetCapacity <T>(other.Length);
}
}
#if ENABLE_UNITY_COLLECTIONS_CHECKS
CheckAllocated(m_Array->Ptr[index]);
var dstList = new NativeList(m_Array->Ptr[index], ref m_Safety);
#else
var dstList = new NativeList(m_Array->Ptr[index]);
#endif
dstList.AddRangeNoResize(other);
return(index);
}
public NativeList AllocateWithCapacityForIndex(int index, int capacity)
{
#if ENABLE_UNITY_COLLECTIONS_CHECKS
AtomicSafetyHandle.CheckWriteAndBumpSecondaryVersion(m_Safety);
#endif
CheckArgPositive(index);
var positiveIndex = AssumePositive(index);
CheckArgInRange(positiveIndex, m_Array->Length);
capacity = Math.Max(1, capacity);
var ptr = m_Array->Ptr[index];
if (ptr == null || !ptr->IsCreated)
{
m_Array->InitializeIndex(index, UnsafeUtility.SizeOf <T>(), UnsafeUtility.AlignOf <T>(), capacity);
}
else
{
ptr->Clear();
if (ptr->Capacity < capacity)
{
ptr->SetCapacity <T>(capacity);
}
}
#if ENABLE_UNITY_COLLECTIONS_CHECKS
CheckAllocated(m_Array->Ptr[index]);
return(new NativeList(m_Array->Ptr[index], ref m_Safety));
#else
return(new NativeList(m_Array->Ptr[index]));
#endif
}
/// <summary>
/// Add an element with the specified key and value into the container. If the key already exist an ArgumentException will be thrown.
/// </summary>
/// <param name="key">The key of the element to add.</param>
/// <param name="item">The value of the element to add.</param>
public void Add(TKey key, TValue item)
{
#if ENABLE_UNITY_COLLECTIONS_CHECKS
AtomicSafetyHandle.CheckWriteAndBumpSecondaryVersion(m_Safety);
#endif
m_Writer.Add(key, item);
}
/// <summary>
/// Truncates the list by removing the items at the specified index range, and shifting all remaining items to replace removed items. The list
/// is shortened by number of elements in range.
/// </summary>
/// <typeparam name="T">Source type of elements</typeparam>
/// <param name="begin">The first index of the item to remove.</param>
/// <param name="end">The index past-the-last item to remove.</param>
/// <remarks>
/// This method of removing item(s) is useful only in case when list is ordered and user wants to preserve order
/// in list after removal In majority of cases is not important and user should use more performant `RemoveRangeSwapBack`.
/// </remarks>
public void RemoveRange(int begin, int end)
{
#if ENABLE_UNITY_COLLECTIONS_CHECKS
AtomicSafetyHandle.CheckWriteAndBumpSecondaryVersion(m_Safety);
#endif
m_ListData->RemoveRange <T>(begin, end);
}
/// <summary>
/// Truncates the list by replacing the item at the specified index range with the items from the end the list. The list
/// is shortened by number of elements in range.
/// </summary>
/// <typeparam name="T">Source type of elements</typeparam>
/// <param name="begin">The first index of the item to remove.</param>
/// <param name="end">The index past-the-last item to remove.</param>
public void RemoveRangeSwapBack(int begin, int end)
{
#if ENABLE_UNITY_COLLECTIONS_CHECKS
AtomicSafetyHandle.CheckWriteAndBumpSecondaryVersion(m_Safety);
#endif
m_ListData->RemoveRangeSwapBack <T>(CollectionHelper.AssumePositive(begin), CollectionHelper.AssumePositive(end));
}
public void Clear()
{
#if ENABLE_UNITY_COLLECTIONS_CHECKS
AtomicSafetyHandle.CheckWriteAndBumpSecondaryVersion(m_Safety);
#endif
ResizeUninitialized(0);
}
public void ResizeUninitialized(int length)
{
#if ENABLE_UNITY_COLLECTIONS_CHECKS
AtomicSafetyHandle.CheckWriteAndBumpSecondaryVersion(m_Safety);
#endif
m_Impl.ResizeUninitialized(length);
}
/// <summary>
/// Clears the list.
/// </summary>
/// <remarks>List <see cref="Capacity"/> remains unchanged.</remarks>
public void Clear()
{
#if ENABLE_UNITY_COLLECTIONS_CHECKS
AtomicSafetyHandle.CheckWriteAndBumpSecondaryVersion(m_Safety);
#endif
m_ListData->Clear();
}
void CheckWriteAccessAndInvalidateArrayAliases()
{
#if ENABLE_UNITY_COLLECTIONS_CHECKS
AtomicSafetyHandle.CheckWriteAndThrow(m_Safety0);
AtomicSafetyHandle.CheckWriteAndBumpSecondaryVersion(m_Safety1);
#endif
}
/// <summary>
/// Adds elements from a buffer to this list.
/// </summary>
/// <param name="elements">A pointer to the buffer.</param>
/// <param name="count">The number of elements to add to the list.</param>
public unsafe void AddRange(void *elements, int count)
{
#if ENABLE_UNITY_COLLECTIONS_CHECKS
AtomicSafetyHandle.CheckWriteAndBumpSecondaryVersion(m_Safety);
#endif
m_ListData->AddRange <T>(elements, count);
}
public void AddRange(NativeArray <T> elements)
{
#if ENABLE_UNITY_COLLECTIONS_CHECKS
AtomicSafetyHandle.CheckWriteAndBumpSecondaryVersion(m_Safety);
#endif
m_Impl.AddRange(elements);
}
public void Push(T value)
{
#if ENABLE_UNITY_COLLECTIONS_CHECKS
AtomicSafetyHandle.CheckWriteAndBumpSecondaryVersion(this.safety);
#endif
this.binaryHeapData->Push(value);
}
/// <summary>
/// Truncates the list by replacing the item at the specified index with the last item in the list. The list
/// is shortened by one.
/// </summary>
/// <param name="index">The index of the item to delete.</param>
/// <exception cref="ArgumentOutOfRangeException">If index is negative or >= <see cref="Length"/>.</exception>
public void RemoveAtSwapBack(int index)
{
#if ENABLE_UNITY_COLLECTIONS_CHECKS
AtomicSafetyHandle.CheckWriteAndBumpSecondaryVersion(m_Safety);
#endif
CheckArgInRange(index, Length);
m_ListData->RemoveAtSwapBack <T>(CollectionHelper.AssumePositive(index));
}
/// <summary>
/// Adds elements from a buffer to this list.
/// </summary>
/// <param name="elements">A pointer to the buffer.</param>
/// <param name="count">The number of elements to add to the list.</param>
/// <exception cref="ArgumentOutOfRangeException">Thrown if count is negative.</exception>
public unsafe void AddRange(void *elements, int count)
{
#if ENABLE_UNITY_COLLECTIONS_CHECKS
AtomicSafetyHandle.CheckWriteAndBumpSecondaryVersion(m_Safety);
CheckArgPositive(count);
#endif
m_ListData->AddRange <T>(elements, CollectionHelper.AssumePositive(count));
}
public void ResizeExact(int length)
{
#if ENABLE_UNITY_COLLECTIONS_CHECKS
AtomicSafetyHandle.CheckWriteAndBumpSecondaryVersion(m_Safety);
#endif
CheckArgPositive(length);
m_Array->ResizeExact(length);
}
public Nullable <T> Pop()
{
#if ENABLE_UNITY_COLLECTIONS_CHECKS
AtomicSafetyHandle.CheckWriteAndBumpSecondaryVersion(this.safety);
#endif
return(this.binaryHeapData->Pop <T>());
}
public void ResizeUninitialized(int length)
{
#if ENABLE_UNITY_COLLECTIONS_CHECKS
AtomicSafetyHandle.CheckWriteAndBumpSecondaryVersion(m_Safety);
#endif
Capacity = Math.Max(length, Capacity);
m_ListData->length = length;
}
public bool IsIndexCreated(int index)
{
#if ENABLE_UNITY_COLLECTIONS_CHECKS
AtomicSafetyHandle.CheckWriteAndBumpSecondaryVersion(m_Safety);
#endif
var ptr = m_Array->Ptr[index];
return(ptr != null && ptr->IsCreated);
}
/// <summary>
/// Changes the list length, resizing if necessary.
/// </summary>
/// <param name="length">The new length of the list.</param>
/// <param name="options">Memory should be cleared on allocation or left uninitialized.</param>
public void Resize(int length, NativeArrayOptions options)
{
#if ENABLE_UNITY_COLLECTIONS_CHECKS
AtomicSafetyHandle.CheckWriteAndBumpSecondaryVersion(m_Safety);
AtomicSafetyHandle.CheckReadAndThrow(m_Safety);
#endif
m_ListData->Resize(UnsafeUtility.SizeOf <T>(), UnsafeUtility.AlignOf <T>(), length, options);
}
/// <summary>
/// Moves the write position to the start of the data buffer used.
/// </summary>
public void Clear()
{
#if ENABLE_UNITY_COLLECTIONS_CHECKS
AtomicSafetyHandle.CheckWriteAndBumpSecondaryVersion(m_Safety);
#endif
m_Data->length = 0;
m_Data->bitIndex = 0;
m_Data->bitBuffer = 0;
}
public void Clear()
{
#if ENABLE_UNITY_COLLECTIONS_CHECKS
AtomicSafetyHandle.CheckWriteAndBumpSecondaryVersion(safetyHandle);
#endif
UnsafeUtility.MemClear(lookup->Ptr, lookup->Capacity * UnsafeUtility.SizeOf <int>());
UnsafeUtility.MemClear(nodes->Ptr, nodes->Capacity * UnsafeUtility.SizeOf <OctNode>());
UnsafeUtility.MemClear(elements->Ptr, elements->Capacity * UnsafeUtility.SizeOf <OctElement <T> >());
elementsCount = 0;
}
public void Clear()
{
#if ENABLE_UNITY_COLLECTIONS_CHECKS
AtomicSafetyHandle.CheckWriteAndBumpSecondaryVersion(safetyHandle);
#endif
lookup->Clear();
nodes->Clear();
elements->Clear();
elementsCount = 0;
}
public void ResizeExact(int length)
{
#if ENABLE_UNITY_COLLECTIONS_CHECKS
AtomicSafetyHandle.CheckWriteAndBumpSecondaryVersion(m_Safety);
#endif
if (length < 0)
{
throw new ArgumentOutOfRangeException(nameof(length), "Length must be >= 0");
}
m_Array->ResizeExact(length);
}
/// <summary>
/// Truncates the list by replacing the item at the specified index with the last item in the list. The list
/// is shortened by one.
/// </summary>
/// <param name="index">The index of the item to delete.</param>
/// <exception cref="ArgumentOutOfRangeException">If index is negative or >= <see cref="Length"/>.</exception>
public void RemoveAtSwapBack(int index)
{
#if ENABLE_UNITY_COLLECTIONS_CHECKS
AtomicSafetyHandle.CheckWriteAndBumpSecondaryVersion(m_Safety);
if (index < 0 || index >= Length)
{
throw new ArgumentOutOfRangeException(index.ToString());
}
#endif
m_ListData->RemoveAtSwapBack <T>(index);
}
