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