Return Slice of Strings from Rust to C#

[slasktotten]

Hi!

I am sure this isn't an actual issue but rather me not understanding how things work.
I am trying give a slice of strings from Rust to C# but can't figure out how to structure the flow.

I've been trying to do something like this (my assumption is Rust should own the underlying CString and then just return an AsciiPointer to it)...

#[ffi_type(opaque)]
pub struct FFIPlayerStruct {
    c_string: CString,
    id: u64
}

#[ffi_service(error = "MyFFIError", prefix = "ffi_player_struct_")]
impl FFIPlayerStruct {

/// omitted constructor

    #[ffi_service_method(on_panic = "return_default")]
    pub fn get_player_name(&self) -> AsciiPointer{
        AsciiPointer::from_cstr(&self.c_string)
    }
}

Some other service holds a vector of player structs. My understanding is that passing a mutable slice with pre-allocated size is how we're meant to pass a vector/array.

    pub fn get_player_structs(&self, buffer: &mut FFISliceMut<FFIPlayerStruct>)  -> Result<(), Error> {
        for (idx, player_struct) in self.player_structs.iter().enumerate() {
            buffer[idx] = FFIPlayerStruct { c_string: player_struct.c_string.clone(), id: player_struct.id }
        }
        Ok(())
    }

The interop bindings generated look like this (I assume the IntPtr is because FFIPlayerStruct is opaque)

        public SliceMutFFIPlayerStruct(NativeArray<IntPtr> handle)
        {
            unsafe
            {
                this.data = new IntPtr(NativeArrayUnsafeUtility.GetUnsafeReadOnlyPtr(handle));
                this.len = (ulong) handle.Length;
            }
        }

My question is if this is the right way to go around the problem and if so - how are you meant to call get_player_name() from an IntPtr? Apologies but my C# isn't the strongest.

Btw, been diving deeper and deeper into the crate over the last few weeks and it's really great!

[ralfbiedert]

My question is if this is the right way to go around the problem and if so - how are you meant to call get_player_name() from an IntPtr? Apologies but my C# isn't the strongest.

Which problem do you mean, and what do you mean by "calling get_player_name from an IntPtr"?

[slasktotten]

By problem I mean: How do I use the returned variable as "the underlying type" i.e. FFIPlayerStruct in my case.

The bindings generated look like this:

        public SliceMutFFIPlayerStruct(GCHandle handle, ulong count)
        {
            this.data = handle.AddrOfPinnedObject();
            this.len = count;
        }
        public SliceMutFFIPlayerStruct(IntPtr handle, ulong count)
        {
            this.data = handle;
            this.len = count;
        }
        #if UNITY_2018_1_OR_NEWER
        public SliceMutFFIPlayerStruct(NativeArray<IntPtr> handle)
        {
            unsafe
            {
                this.data = new IntPtr(NativeArrayUnsafeUtility.GetUnsafeReadOnlyPtr(handle));
                this.len = (ulong) handle.Length;
            }
        }

This is how I am trying to use the bindings in C#. Maybe I am misunderstanding how to create the FFISlices?

        int len = Bindings.UnityWrapper.GetFFIPlayerStructsLen();
        var output  = new NativeArray<IntPtr>(len, Allocator.Temp);
        Bindings.UnityWrapper.SliceMutFFIPlayerStruct mut_slice = new Bindings.UnityWrapper.SliceMutFFIPlayerStruct(output);
        interop.GetPlayerStructs(ref mut_slice);

        foreach (IntPtr item in output) {
            Debug.Log(item.GetPlayerName()); // i understand this doesn't work but is where i get stuck, how can i treat IntPtr like the underlying FFIPlayerStruct 
        }

I hope this makes sense! Many thanks for taking the time helping out.

[ralfbiedert]

I still have some trouble following, but do you do buffer: &mut FFISliceMut<FFIPlayerStruct> on purpose?

This at least might contribute to any issue. You are passing a reference to a slice, which isn't well supported (and really only needed if you want to interface with the Burst compiler). FFISliceMut is already a pointer (well, plus length), and it should translate to proper array methods on C#.

In other words, try this:

pub fn get_player_structs(&self, buffer: FFISliceMut<FFIPlayerStruct>) -> Result<(), Error> { ... }

If that's not it, could you please push a self-contained "almost compiling" MVP somewhere, I have some trouble "compiling" this problem in my mind as-is.

[slasktotten]

Hey, sorry for delay in response!
repository
The question comes down to 'how can i use get_player_data... from C#?

Hope this makes sense and merry christmas :-)