WIP demo nicer FFI types

rust/src/util/api.rs

@@ -5,7 +5,7 @@ use std::sync::Once;
 
 use ffi_toolkit::{catch_panic_response, raw_ptr, rust_str_to_c_str, FCPResponseStatus};
 
-use super::types::{fil_GpuDeviceResponse, fil_InitLogFdResponse};
+use super::types::{fil_Bytes, fil_GpuDeviceResponse, fil_InitLogFdResponse};
 
 /// Protects the init off the logger.
 static LOG_INIT: Once = Once::new();
@@ -38,20 +38,8 @@ pub unsafe extern "C" fn fil_get_gpu_devices() -> *mut fil_GpuDeviceResponse {
         let devices = rust_gpu_tools::Device::all();
         let n = devices.len();
 
-        let devices: Vec<*const libc::c_char> = devices
-            .iter()
-            .map(|d| d.name())
-            .map(|d| {
-                CString::new(d)
-                    .unwrap_or_else(|_| CString::new("Unknown").unwrap())
-                    .into_raw() as *const libc::c_char
-            })
-            .collect();
-
-        let dyn_array = Box::into_raw(devices.into_boxed_slice());
-
-        response.devices_len = n;
-        response.devices_ptr = dyn_array as *const *const libc::c_char;
+        let devices: Vec<fil_Bytes> = devices.iter().map(|d| d.name().into()).collect();
+        response.devices = devices.into();
 
         raw_ptr(response)
     })

rust/src/util/types.rs

@@ -1,25 +1,115 @@
-use std::ptr;
+use std::{ops::Deref, ptr};
 
 use drop_struct_macro_derive::DropStructMacro;
 // `CodeAndMessage` is the trait implemented by `code_and_message_impl
 use ffi_toolkit::{code_and_message_impl, free_c_str, CodeAndMessage, FCPResponseStatus};
 
 #[repr(C)]
-#[derive(DropStructMacro)]
+pub struct fil_Array<T: Sized> {
+    ptr: *mut T,
+    len: usize,
+}
+
+impl<T> Default for fil_Array<T> {
+    fn default() -> Self {
+        Self {
+            ptr: ptr::null_mut(),
+            len: 0,
+        }
+    }
+}
+
+pub type fil_Bytes = fil_Array<u8>;
+
+impl<T> From<Vec<T>> for fil_Array<T> {
+    fn from(buf: Vec<T>) -> Self {
+        if buf.is_empty() {
+            return Default::default();
+        }
+        buf.into_boxed_slice().into()
+    }
+}
+
+impl<T> From<Box<[T]>> for fil_Array<T> {
+    fn from(buf: Box<[T]>) -> Self {
+        if buf.is_empty() {
+            return Default::default();
+        }
+        let len = buf.len();
+        let ptr = buf.as_mut_ptr();
+        Box::leak(buf);
+
+        Self { ptr, len }
+    }
+}
+
+impl<T> Drop for fil_Array<T> {
+    fn drop(&mut self) {
+        unsafe {
+            if !self.ptr.is_null() && self.len != 0 {
+                let _ = Vec::from_raw_parts(self.ptr, self.len, self.len);
+            }
+        }
+    }
+}
+
+impl<T> Deref for fil_Array<T> {
+    type Target = [T];
+    fn deref(&self) -> &[T] {
+        unsafe {
+            if self.ptr.is_null() {
+                std::slice::from_raw_parts(ptr::NonNull::dangling().as_ptr(), 0)
+            } else {
+                std::slice::from_raw_parts(self.ptr, self.len)
+            }
+        }
+    }
+}
+
+impl From<&str> for fil_Bytes {
+    fn from(s: &str) -> Self {
+        if s.is_empty() {
+            return Default::default();
+        }
+        Box::<str>::from(s).into()
+    }
+}
+
+impl From<String> for fil_Bytes {
+    fn from(s: String) -> Self {
+        if s.is_empty() {
+            return Default::default();
+        }
+        s.into_boxed_str().into()
+    }
+}
+
+impl From<Box<str>> for fil_Bytes {
+    fn from(s: Box<str>) -> Self {
+        if s.is_empty() {
+            return Default::default();
+        }
+        let len = s.len();
+        let ptr = s.as_mut_ptr();
+        Box::leak(s);
+
+        Self { ptr, len }
+    }
+}
+
+#[repr(C)]
 pub struct fil_GpuDeviceResponse {
     pub status_code: FCPResponseStatus,
-    pub error_msg: *const libc::c_char,
-    pub devices_len: libc::size_t,
-    pub devices_ptr: *const *const libc::c_char,
+    pub error_msg: fil_Bytes,
+    pub devices: fil_Array<fil_Bytes>,
 }
 
 impl Default for fil_GpuDeviceResponse {
     fn default() -> Self {
         Self {
-            error_msg: ptr::null(),
+            error_msg: Default::default(),
             status_code: FCPResponseStatus::FCPNoError,
-            devices_len: 0,
-            devices_ptr: ptr::null(),
+            devices: Default::default(),
         }
     }
 }