Is there a way to map an out param1** that is an array of structs of length param2?

[kmgallahan]

As per the title, I can't quite figure out if it is possible to map this type of function:

CrError GetDeviceProperties(/*in*/ CrDeviceHandle deviceHandle, /*out*/CrDeviceProperty** properties, /*out*/ CrInt32* numOfPropoties);

Where the second out param is a ** to an array of structs of type CrDeviceProperty of the length of the 3rd param, as per the documentation:

The first one is the device handle that specifies the device, the second
one is the pointer to CrDeviceProperty pointer that receives the acquired property list, and the third one
receives the size of the CrDeviceProperty list.

I'm aware of the Length Relation, but it appears to only be for in params. I also don't know how to deal with ** params.

Current mapping for this header produces:

public static unsafe int GetDeviceProperties(long deviceHandle, out System.IntPtr properties, out int numOfProperties)
{
      int __result__;
      fixed (void *numOfProperties_ = &numOfProperties)
          fixed (void *properties_ = &properties)
              __result__ = GetDeviceProperties_(deviceHandle, properties_, numOfProperties_);
      return __result__;
}

[andrew-boyarshin]

I believe we've blocked this specifically. It's due to the unknown allocation strategy, we cannot guarantee how it's supposed to be deallocated, therefore we can't lose the raw pointer. We offer MarshallingHelpers.Read for that.

[kmgallahan]

Did you mean MarshallingHelpers.FromPointer? I don't see a read anywhere.

SharpGenTools/SharpGen.Runtime/MarshallingHelpers.cs

Line 14 in fe286fc

public static T FromPointer<T>(IntPtr cppObjectPtr) where T : CppObject =>

[andrew-boyarshin]

Whoops, I meant MemoryHelpers, actually.

SharpGenTools/SharpGen.Runtime/MemoryHelpers.cs

Lines 121 to 194 in fe286fc

	/// <summary>
	/// Reads the specified array T[] data from a memory location.
	/// </summary>
	/// <typeparam name="T">Type of a data to read.</typeparam>
	/// <param name="source">Memory location to read from.</param>
	/// <param name="data">The data write to.</param>
	/// <param name="offset">The offset in the array to write to.</param>
	/// <param name="count">The number of T element to read from the memory location.</param>
	/// <returns>source pointer + sizeof(T) * count.</returns>
	public static IntPtr Read<T>(IntPtr source, T[] data, int offset, int count) where T : unmanaged
	{
	return Read(source, new ReadOnlySpan<T>(data).Slice(offset), count);
	}
	/// <summary>
	/// Reads the specified array data from a memory location.
	/// </summary>
	/// <typeparam name="T">Type of a data to read.</typeparam>
	/// <param name="source">Memory location to read from.</param>
	/// <param name="data">The data write to.</param>
	/// <param name="offset">The offset in the array to write to.</param>
	/// <param name="count">The number of T element to read from the memory location.</param>
	/// <returns>source pointer + sizeof(T) * count.</returns>
	public static IntPtr Read<T>(IntPtr source, ReadOnlySpan<T> data, int count) where T : unmanaged
	{
	unsafe
	{
	fixed (void* dataPtr = data)
	{
	Unsafe.CopyBlockUnaligned(dataPtr, (void*)source, (uint)(count * Unsafe.SizeOf<T>()));
	return source + Unsafe.SizeOf<T>() * count;
	}
	}
	}
	/// <summary>
	/// Writes the specified array T[] data to a memory location.
	/// </summary>
	/// <typeparam name="T">Type of a data to write.</typeparam>
	/// <param name="destination">Memory location to write to.</param>
	/// <param name="data">The span of T data to write.</param>
	/// <param name="count">The number of T element to write to the memory location.</param>
	/// <returns>destination pointer + sizeof(T) * count.</returns>
	public static IntPtr Write<T>(IntPtr destination, Span<T> data, int count) where T : unmanaged
	{
	unsafe
	{
	fixed (void* dataPtr = data)
	{
	Unsafe.CopyBlockUnaligned((void*)destination, dataPtr, (uint)(count * Unsafe.SizeOf<T>()));
	return destination + Unsafe.SizeOf<T>() * count;
	}
	}
	}
	/// <summary>
	/// Reads the specified array data from a memory location.
	/// </summary>
	/// <typeparam name="T">Type of a data to read.</typeparam>
	/// <param name="source">Memory location to read from.</param>
	/// <param name="data">The T to read to.</param>
	/// <returns>source pointer + sizeof(T).</returns>
	public static unsafe IntPtr Read<T>(IntPtr source, ref T data) where T : unmanaged =>
	Read(source, new ReadOnlySpan<T>(Unsafe.AsPointer(ref data), 1), 1);
	/// <summary>
	/// Writes the specified array T data to a memory location.
	/// </summary>
	/// <typeparam name="T">Type of a data to write.</typeparam>
	/// <param name="destination">Memory location to write to.</param>
	/// <param name="data">The data structure to write.</param>
	/// <returns>destination pointer + sizeof(T).</returns>
	public static unsafe IntPtr Write<T>(IntPtr destination, ref T data) where T : unmanaged =>
	Write(destination, new Span<T>(Unsafe.AsPointer(ref data), 1), 1);

[kmgallahan]

Great success! Getting this function to work was a prerequisite to executing the shutter release command which just allowed me to take my first photo! Thank you! ❤❤❤

Is there any way to reward you for your kind efforts in helping me out? The project has no donation methods that I see.

[kmgallahan]

@jkoritzinsky

Are there plans to add a "hint" to SharpGenTools to let it know how to deallocate this type of pointer? At least for this use case I just have boilerplate:

var getDevicePropertiesResult = CR_Core.GetDeviceProperties(handle, out var props, out var numProps);
var deviceProps = new CrDeviceProperty[numProps];
MemoryHelpers.Read(props, deviceProps, 0, numProps);

Perhaps even an overload of MemoryHelpers.Read for convenience:

public static IntPtr Read<T>(IntPtr source, out T[] data, int count) where T : unmanaged
{
    return Read(source, new ReadOnlySpan<T>(data = new T[count]), count);
}

To simply down to:

var getDevicePropertiesResult = CR_Core.GetDeviceProperties(handle, out var props, out var numProps);
MemoryHelpers.Read(props, out CrDeviceProperty[] deviceProps, numProps);