/// <summary>Insert an item into the array at a given index</summary>
/// <param name="array">The array</param>
/// <param name="itemToInsert">The item to insert</param>
/// <param name="index">The index to insert the item at</param>
/// <returns>`true` if successful</returns>
public static bool ATGenericArrayInsertItem(Foundation.ATGenericArrayUnsafe array, IntPtr itemToInsert, ulong index)
{
var _arg0 = ReferenceEquals(array, null) ? IntPtr.Zero : array._Instance;
var _ret = _Internal.ATGenericArrayInsertItem(_arg0, itemToInsert, index);
return(_ret);
}
/// <summary>Remove all items</summary>
/// <param name="array">The array</param>
/// <returns>`true` if successful</returns>
/// <remarks>Will not zero out items removed</remarks>
public static bool ATGenericArrayRemoveAllItems(Foundation.ATGenericArrayUnsafe array)
{
var _arg0 = ReferenceEquals(array, null) ? IntPtr.Zero : array._Instance;
var _ret = _Internal.ATGenericArrayRemoveAllItems(_arg0);
return(_ret);
}
/// <summary>Append an item to the array</summary>
/// <param name="array">The array</param>
/// <param name="itemToAppend">A pointer to the item to append</param>
/// <returns>`true` if successful</returns>
public static bool ATGenericArrayAppendItem(Foundation.ATGenericArrayUnsafe array, IntPtr itemToAppend)
{
var _arg0 = ReferenceEquals(array, null) ? IntPtr.Zero : array._Instance;
var _ret = _Internal.ATGenericArrayAppendItem(_arg0, itemToAppend);
return(_ret);
}
/// <summary>Get a pointer to an item in the array</summary>
/// <param name="array">The array</param>
/// <param name="index">The index of the item to retrieve</param>
/// <returns>A pointer to the item</returns>
public static IntPtr ATGenericArrayGetPointerForItem(Foundation.ATGenericArrayUnsafe array, ulong index)
{
var _arg0 = ReferenceEquals(array, null) ? IntPtr.Zero : array._Instance;
var _ret = _Internal.ATGenericArrayGetPointerForItem(_arg0, index);
return(_ret);
}
public ATGenericArrayUnsafe(Foundation.ATGenericArrayUnsafe _0)
{
_Instance = Marshal.AllocHGlobal(sizeof(Foundation.ATGenericArrayUnsafe._Internal));
_ownsNativeInstance = true;
NativeToManagedMap[_Instance] = this;
*((Foundation.ATGenericArrayUnsafe._Internal *)_Instance) = *((Foundation.ATGenericArrayUnsafe._Internal *)_0._Instance);
}
/// <summary>Determine if two arrays are equal</summary>
/// <param name="array1">The first array</param>
/// <param name="array2">The second array</param>
/// <returns>`true` if the arrays are equal (the contents of the array are equal)</returns>
public static bool ATGenericArrayIsEqual(Foundation.ATGenericArrayUnsafe array1, Foundation.ATGenericArrayUnsafe array2)
{
var _arg0 = ReferenceEquals(array1, null) ? IntPtr.Zero : array1._Instance;
var _arg1 = ReferenceEquals(array2, null) ? IntPtr.Zero : array2._Instance;
var _ret = _Internal.ATGenericArrayIsEqual(_arg0, _arg1);
return(_ret);
}
/// <summary>Copy an array. Will attempt to resize destination if destination capacity is less than source length</summary>
/// <param name="destination">The destination array</param>
/// <param name="source">The source array</param>
/// <returns>`true` if successful</returns>
public static bool ATGenericArrayCopy(Foundation.ATGenericArrayUnsafe destination, Foundation.ATGenericArrayUnsafe source)
{
var _arg0 = ReferenceEquals(destination, null) ? IntPtr.Zero : destination._Instance;
var _arg1 = ReferenceEquals(source, null) ? IntPtr.Zero : source._Instance;
var _ret = _Internal.ATGenericArrayCopy(_arg0, _arg1);
return(_ret);
}
/// <summary>Initialize a new generic array object from existing data</summary>
/// <param name="array">The object to initialize. Can be `NULL` so the result from `ATGenericArrayNew` can be passed directly, in which case it will simply return `NULL`</param>
/// <param name="existingData">The existing data to copy from</param>
/// <param name="length">The length of the existing data (number of items)</param>
/// <param name="bytesPerItem">The number of bytes per item</param>
/// <returns>The initialized object or `NULL` if initialization failed</returns>
public static Foundation.ATGenericArrayUnsafe ATGenericArrayInitWithItems(Foundation.ATGenericArrayUnsafe array, IntPtr existingData, ulong length, ulong bytesPerItem)
{
var _arg0 = ReferenceEquals(array, null) ? IntPtr.Zero : array._Instance;
var _ret = _Internal.ATGenericArrayInitWithItems(_arg0, existingData, length, bytesPerItem);
Foundation.ATGenericArrayUnsafe _result0;
if (_ret == IntPtr.Zero)
{
_result0 = null;
}
else if (Foundation.ATGenericArrayUnsafe.NativeToManagedMap.ContainsKey(_ret))
{
_result0 = (Foundation.ATGenericArrayUnsafe)Foundation.ATGenericArrayUnsafe.NativeToManagedMap[_ret];
}
else
{
_result0 = Foundation.ATGenericArrayUnsafe._CreateInstance(_ret);
}
return(_result0);
}
/// <summary>Create a new generic array object</summary>
/// <param name="optionalStorage">Optionally, a pointer to a struct or memory where the object can be stored</param>
/// <returns>A pointer to the new object. `NULL` if allocation could not be completed</returns>
public static Foundation.ATGenericArrayUnsafe ATGenericArrayNew(Foundation.ATGenericArrayUnsafe optionalStorage)
{
var _arg0 = ReferenceEquals(optionalStorage, null) ? IntPtr.Zero : optionalStorage._Instance;
var _ret = _Internal.ATGenericArrayNew(_arg0);
Foundation.ATGenericArrayUnsafe _result0;
if (_ret == IntPtr.Zero)
{
_result0 = null;
}
else if (Foundation.ATGenericArrayUnsafe.NativeToManagedMap.ContainsKey(_ret))
{
_result0 = (Foundation.ATGenericArrayUnsafe)Foundation.ATGenericArrayUnsafe.NativeToManagedMap[_ret];
}
else
{
_result0 = Foundation.ATGenericArrayUnsafe._CreateInstance(_ret);
}
return(_result0);
}
