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); }