public static T[] ToArray <T>(this AiNativeList <T> list) where T : unmanaged { T[] array = new T[list.Length]; int length = list.Length * UnsafeCollectionUtility.SizeOf <T>(); MemoryCopy.Copy((T *)list.GetUnsafePtr(), array, length); return(array); }
public T ReadElement <T>(int index) where T : unmanaged { #if DEBUG || ENABLE_UNITY_COLLECTIONS_CHECKS RequireCreated(); RequireIndexInBounds(index); #endif return(UnsafeCollectionUtility.ReadArrayElement <T>(Ptr, index)); }
public static byte[] ToByteArray <T>(this AiNativeList <T> list) where T : unmanaged { int bytesToCopy = list.Length * UnsafeCollectionUtility.SizeOf <T>(); byte[] target = new byte[bytesToCopy]; MemoryCopy.Copy(list.GetUnsafePtr(), 0, target, 0, bytesToCopy); return(target); }
public static byte[] ToByteArray <T>(this T[] source) where T : unmanaged { int sizeInBytes = source.Length * UnsafeCollectionUtility.SizeOf <T>(); byte[] target = new byte[sizeInBytes]; MemoryCopy.Copy(source, target); return(target); }
public void WriteElement <T>(int index, T value) where T : unmanaged { #if DEBUG || ENABLE_UNITY_COLLECTIONS_CHECKS RequireCreated(); RequireIndexInBounds(index); #endif UnsafeCollectionUtility.WriteArrayElement <T>(Ptr, index, value); }
public AiNativeArray(int length) { if (length <= 0) { throw new ArgumentException("Length must be > 0"); } m_Data = UnsafeArrayData.Create(UnsafeCollectionUtility.SizeOf <T>(), length); }
public static UnsafeArrayData *Create(int sizeOf, int length) { UnsafeArrayData *arrayData = (UnsafeArrayData *)Marshal.AllocHGlobal(UnsafeCollectionUtility.SizeOf <UnsafeArrayData>()); var bytesToMalloc = sizeOf * length; arrayData->Ptr = (void *)Marshal.AllocHGlobal(bytesToMalloc); arrayData->Length = length; return(arrayData); }
public static int IndexOf <T, U>(void *ptr, int length, U value) where T : unmanaged, IEquatable <U> { for (int i = 0; i != length; i++) { if (UnsafeCollectionUtility.ReadArrayElement <T>(ptr, i).Equals(value)) { return(i); } } return(-1); }
public static T[] ToArray <T>(this byte[] source) where T : unmanaged { if (source.Length % UnsafeCollectionUtility.SizeOf <T>() != 0) { throw new ArgumentException("Invalid length for type"); } int size = source.Length / UnsafeCollectionUtility.SizeOf <T>(); T[] target = new T[size]; MemoryCopy.Copy <T>(source, target); return(target); }
public static AiNativeArray <T> ToNativeArray <T>(this byte[] source) where T : unmanaged { if (source.Length % UnsafeCollectionUtility.SizeOf <T>() != 0) { throw new ArgumentException("Invalid length for type"); } int size = source.Length / UnsafeCollectionUtility.SizeOf <T>(); AiNativeArray <T> destination = new AiNativeArray <T>(size); MemoryCopy.Copy(source, 0, destination.GetUnsafePtr(), 0, source.Length); return(destination); }
public static UnsafeListData *Create(int sizeOf, int initialCapacity) { UnsafeListData *listData = (UnsafeListData *)Marshal.AllocHGlobal(UnsafeCollectionUtility.SizeOf <UnsafeListData>()); listData->Length = 0; listData->Capacity = 0; if (initialCapacity != 0) { listData->SetCapacity(sizeOf, initialCapacity); } return(listData); }
public static UnsafeListData *CreateFrom <T>(byte[] array) where T : unmanaged { if (array.Length % UnsafeCollectionUtility.SizeOf <T>() != 0) { throw new ArgumentException("Invalid length for type"); } int size = array.Length / UnsafeCollectionUtility.SizeOf <T>(); UnsafeListData *listData = Create(UnsafeCollectionUtility.SizeOf <T>(), size); listData->Length = size; MemoryCopy.Copy(array, 0, listData->Ptr, 0, array.Length); return(listData); }
public static UnsafeListData *CreateFrom <T>(AiNativeArray <T> array) where T : unmanaged { UnsafeListData *listData = Create(UnsafeCollectionUtility.SizeOf <T>(), array.Length); if (listData->Capacity < array.Length) { listData->Dispose(); throw new Exception("Unknown Error"); } listData->Length = array.Length; int bytesToCopy = array.Length * UnsafeCollectionUtility.SizeOf <T>(); Buffer.MemoryCopy(array.GetUnsafePtr(), listData->Ptr, bytesToCopy, bytesToCopy); return(listData); }
private void SetCapacity(int sizeOf, int capacity) { if (capacity > 0) { var itemsPerCacheLine = 64 / sizeOf; if (capacity < itemsPerCacheLine) { capacity = itemsPerCacheLine; } capacity = UnsafeCollectionUtility.CeilPow2(capacity); } var newCapacity = capacity; if (newCapacity == Capacity) { return; } void *newPointer = null; if (newCapacity > 0) { var bytesToMalloc = sizeOf * newCapacity; newPointer = (void *)Marshal.AllocHGlobal(bytesToMalloc); if (Capacity > 0) { var itemsToCopy = newCapacity < Capacity ? newCapacity : Capacity; var bytesToCopy = itemsToCopy * sizeOf; Buffer.MemoryCopy(Ptr, newPointer, bytesToCopy, bytesToCopy); } } if (Capacity > 0) { Marshal.FreeHGlobal((IntPtr)Ptr); } Ptr = newPointer; Capacity = newCapacity; Length = Math.Min(Length, Capacity); }
public AiNativeList(int initialCapacity) { m_ListData = UnsafeListData.Create(UnsafeCollectionUtility.SizeOf <T>(), initialCapacity); }
public void RemoveRangeSwapBack <T>(int begin, int end) where T : unmanaged { RemoveRangeSwapBack(UnsafeCollectionUtility.SizeOf <T>(), begin, end); }
public void AddRange <T>(UnsafeListData list) where T : unmanaged { AddRange(UnsafeCollectionUtility.SizeOf <T>(), list.Ptr, list.Length); }
public void AddRange <T>(void *ptr, int length) where T : unmanaged { AddRange(UnsafeCollectionUtility.SizeOf <T>(), ptr, length); }
public void Add <T>(T value) where T : unmanaged { Resize(UnsafeCollectionUtility.SizeOf <T>(), Length + 1); WriteElement(Length - 1, value); }