/// <summary>
/// Copies a specified number of bytes from a source buffer to a destination buffer.
/// </summary>
/// <param name="src">The source buffer.</param>
/// <param name="dst">The destination buffer.</param>
/// <param name="count">The number of bytes to copy.</param>
public static unsafe void Copy(byte[] src, void *dst, int count)
{
fixed(byte *numRef = src)
{
CMemory.Copy(numRef, dst, count);
}
}
/// <summary>
/// Copies a specified number of bytes from a source buffer starting at a particular offset to a destination buffer starting at a particular offset.
/// </summary>
/// <param name="src">The source buffer.</param>
/// <param name="srcOffset">The byte offset into ptr2.</param>
/// <param name="dst">The destination buffer.</param>
/// <param name="dstOffset">The byte offset into ptr1.</param>
/// <param name="count">The number of bytes to copy.</param>
public static unsafe void Copy(byte[] src, int srcOffset, void *dst, int dstOffset, int count)
{
fixed(byte *numRef = src)
{
CMemory.Copy(numRef + srcOffset, (byte *)dst + dstOffset, count);
}
}
/// <summary>
/// Copies a specified number of bytes from an array of 64-bit double starting at a particular offset to a destination buffer.
/// </summary>
/// <param name="src">The source buffer.</param>
/// <param name="srcOffset">The byte offset into source array of double values.</param>
/// <param name="dst">The destination buffer.</param>
/// <param name="count">The number of bytes to copy.</param>
public static unsafe void Copy(double[] src, int srcOffset, void *dst, int count)
{
fixed(double *src_p = src)
{
CMemory.Copy(src_p + srcOffset, dst, count);
}
}
/// <summary>
/// Copies a specified number of bytes from a source buffer starting at a particular offset to a destination buffer starting at a particular offset.
/// </summary>
/// <param name="src">The source buffer.</param>
/// <param name="srcOffset">The byte offset into ptr2.</param>
/// <param name="dst">The destination buffer.</param>
/// <param name="dstOffset">The byte offset into ptr1.</param>
/// <param name="count">The number of bytes to copy.</param>
public static unsafe void Copy(void *src, int srcOffset, byte[] dst, int dstOffset, int count)
{
fixed(byte *numRef = dst)
{
CMemory.Copy((byte *)src + srcOffset, numRef + dstOffset, count);
}
}
/// <summary>
/// Copies a specified number of bytes from a source buffer to an array of 64-bit double starting at a particular offset.
/// </summary>
/// <param name="src">The source buffer.</param>
/// <param name="dst">The destination buffer.</param>
/// <param name="dstOffset">The byte offset into the destination array of double values.</param>
/// <param name="count">The number of bytes to copy.</param>
public static unsafe void Copy(void *src, double[] dst, int dstOffset, int count)
{
fixed(double *dst_p = dst)
{
CMemory.Copy(src, dst_p + dstOffset, count);
}
}
/// <summary>
/// Copies a specified number of bytes from an array of 64-bit integer starting at a particular offset to a destination buffer starting at a particular offset.
/// </summary>
/// <param name="src">The source buffer.</param>
/// <param name="srcOffset">The byte offset into ptr2.</param>
/// <param name="dst">The destination buffer.</param>
/// <param name="dstOffset">The byte offset into ptr1.</param>
/// <param name="count">The number of bytes to copy.</param>
public static unsafe void Copy(long[] src, int srcOffset, byte[] dst, int dstOffset, int count)
{
fixed(long *src_p = src)
{
fixed(byte *numRef = dst)
{
CMemory.Copy((byte *)src_p + srcOffset, numRef + dstOffset, count);
}
}
}
/// <summary>
/// Copies a specified number of bytes from an array of 64-bit double starting at a particular offset to a destination buffer starting at a particular offset.
/// </summary>
/// <param name="src">The source array of double values.</param>
/// <param name="srcOffset">The offset into the source array.</param>
/// <param name="dst">The destination array of double values.</param>
/// <param name="dstOffset">THe offset into the destination array.</param>
/// <param name="count">Note: The number of double values.</param>
public static void Copy(double[] src, int srcOffset, double[] dst, int dstOffset, int count)
{
fixed(double *src_p = src)
{
fixed(double *dst_p = dst)
{
CMemory.Copy(src_p + srcOffset, dst_p + dstOffset, count << 3);
}
}
}
internal static void SetMaxWorkingSet(ulong size)
{
CMemory.SetMaxWorkingSet(size);
}
public static unsafe void *malloc(ulong size)
{
return(CMemory.C_malloc(size));
}
public static unsafe void free(void *buff)
{
CMemory.C_free(buff);
}
/// <summary>
/// Copies a specified number of bytes from a source buffer starting at a particular offset to a destination buffer starting at a particular offset.
/// </summary>
/// <param name="src">The source buffer.</param>
/// <param name="srcOffset">The byte offset into ptr2.</param>
/// <param name="dst">The destination buffer.</param>
/// <param name="dstOffset">The byte offset into ptr1.</param>
/// <param name="count">The number of bytes to copy.</param>
public static unsafe void Copy(void *src, int srcOffset, void *dst, int dstOffset, int count)
{
CMemory.Copy((byte *)src + srcOffset, (byte *)dst + dstOffset, count);
}
public static unsafe void *_aligned_malloc(long size, long alignment)
{
return(CMemory.C_aligned_malloc(size, alignment));
}
public static unsafe void *memset(void *buff, int value, ulong count)
{
return(CMemory.C_memset(buff, value, count));
}
public static unsafe int memcmp(void *ptr1, void *ptr2, ulong count)
{
return(CMemory.C_memcmp(ptr1, ptr2, count));
}
public static unsafe void *realloc(void *buff, ulong size)
{
return(CMemory.C_realloc(buff, size));
}
public static void _aligned_free(void *mem)
{
CMemory.C_aligned_free(mem);
}
internal static void SetMemoryAllocationProfile(MemoryAllocationProfile profile)
{
CMemory.SetMemoryAllocationProfile(profile);
}
private static void SetWorkingSetProfile(int profile)
{
CMemory.SetWorkingSetProfile(profile);
}
public static void *AlignedAlloc(long size, long alignment)
{
return(CMemory.AlignedAlloc(size, alignment));
}
public static unsafe void Copy(void *src, void *dst, int count)
{
CMemory.Copy(src, dst, count);
}
public static unsafe void *memcpy(void *dst, void *src, ulong count)
{
return(CMemory.C_memcpy(dst, src, count));
}
/// <summary>
/// Compare bytes in two buffers.
/// </summary>
/// <param name="buff1">First buffer.</param>
/// <param name="buff2">Second buffer.</param>
/// <param name="count">Number of bytes to compare.</param>
/// <returns>true if buff1 identical to buff2, otherwise false.</returns>
public static unsafe bool Compare(byte *buff1, byte *buff2, int count)
{
return(CMemory.C_memcmp(buff2, buff1, (ulong)count) == 0);
}
public static unsafe void *memmove(void *dst, void *src, ulong count)
{
return(CMemory.memmove(dst, src, count));
}
