/// <summary> /// Writes a single element to the memory location, taking into account the alignment. /// </summary> /// <typeparam name="T">Struct type</typeparam> /// <param name="pDest">Pointer to memory location</param> /// <param name="data">The value to write</param> public static unsafe void WriteAligned <T>(IntPtr pDest, ref T data) where T : struct { int pad = (int)(pDest.ToInt64() % (long)IntPtr.Size); InternalInterop.WriteInline <T>((void *)AddIntPtr(pDest, pad), ref data); }
/// <summary> /// Writes data from the array to the memory location. /// </summary> /// <typeparam name="T">Struct type</typeparam> /// <param name="pDest">Pointer to memory location</param> /// <param name="data">Array containing data to write</param> /// <param name="startIndexInArray">Zero-based element index to start reading data from in the element array.</param> /// <param name="count">Number of elements to copy</param> public static unsafe void Write <T>(IntPtr pDest, T[] data, int startIndexInArray, int count) where T : struct { InternalInterop.WriteArray <T>(pDest, data, startIndexInArray, count); }
/// <summary> /// Writes a single element to the memory location. /// </summary> /// <typeparam name="T">Struct type</typeparam> /// <param name="pDest">Pointer to memory location</param> /// <param name="data">The value to write</param> public static unsafe void Write <T>(IntPtr pDest, ref T data) where T : struct { InternalInterop.WriteInline <T>((void *)pDest, ref data); }
/// <summary> /// Reads a single element from the memory location. /// </summary> /// <typeparam name="T">Struct type</typeparam> /// <param name="pSrc">Pointer to memory location</param> /// <returns>The read value</returns> public static unsafe T Read <T>(IntPtr pSrc) where T : struct { return(InternalInterop.ReadInline <T>((void *)pSrc)); }
/// <summary> /// Reads a single element from the memory location, taking into account the alignment. /// </summary> /// <typeparam name="T">Struct type</typeparam> /// <param name="pSrc">Pointer to memory location</param> /// <returns>The read value</returns> public static unsafe T ReadAligned <T>(IntPtr pSrc) where T : struct { int pad = (int)(pSrc.ToInt64() % (long)IntPtr.Size); return(InternalInterop.ReadInline <T>((void *)AddIntPtr(pSrc, pad))); }
/// <summary> /// Reads data from the memory location into the array. /// </summary> /// <typeparam name="T">Struct type</typeparam> /// <param name="pSrc">Pointer to memory location</param> /// <param name="data">Array to store the copied data</param> /// <param name="startIndexInArray">Zero-based element index to start writing data to in the element array.</param> /// <param name="count">Number of elements to copy</param> public static unsafe void Read <T>(IntPtr pSrc, T[] data, int startIndexInArray, int count) where T : struct { InternalInterop.ReadArray <T>(pSrc, data, startIndexInArray, count); }
/// <summary> /// Performs a memcopy that copies data from the memory pointed to by the source pointer to the memory pointer by the destination pointer. /// </summary> /// <param name="pDest">Destination memory location</param> /// <param name="pSrc">Source memory location</param> /// <param name="sizeInBytesToCopy">Number of bytes to copy</param> public static unsafe void CopyMemory(IntPtr pDest, IntPtr pSrc, int sizeInBytesToCopy) { InternalInterop.MemCopyInline((void *)pDest, (void *)pSrc, sizeInBytesToCopy); }
/// <summary> /// Computes the size of the struct array. Only use if the type is blittable, where marshaling by the runtime is NOT required /// (e.g. does not have MarshalAs attributes and can have its raw bytes copied), otherwise use the Marshal SizeOf methods for non-blittable types. /// </summary> /// <typeparam name="T">Struct type</typeparam> /// <param name="array">Array of structs</param> /// <returns>Total size, in bytes, of the array's contents.</returns> public static int SizeOf <T>(T[] array) where T : struct { return(array == null ? 0 : array.Length *InternalInterop.SizeOfInline <T>()); }
/// <summary> /// Computes the size of the struct type. Only use if the type is blittable, where marshaling by the runtime is NOT required /// (e.g. does not have MarshalAs attributes and can have its raw bytes copied), otherwise use the Marshal SizeOf methods for non-blittable types. /// </summary> /// <typeparam name="T">Struct type</typeparam> /// <returns>Size of the struct in bytes.</returns> public static unsafe int SizeOf <T>() where T : struct { return(InternalInterop.SizeOfInline <T>()); }
/// <summary> /// Clears the memory to the specified value. /// </summary> /// <param name="memoryPtr">Pointer to the memory.</param> /// <param name="clearValue">Value the memory will be cleared to.</param> /// <param name="sizeInBytesToClear">Number of bytes, starting from the memory pointer, to clear.</param> public static unsafe void ClearMemory(IntPtr memoryPtr, byte clearValue, int sizeInBytesToClear) { InternalInterop.MemSetInline((void *)memoryPtr, clearValue, sizeInBytesToClear); }