dispatch2: Add fn data_create() which copies a slice

Author: MarijnS95

Cargo.lock

@@ -1,9 +1,13 @@
 //! Dispatch object definition.
 
 use alloc::boxed::Box;
+use core::{ops::Deref, ptr::NonNull};
 
 use super::{ffi::*, queue::Queue, utils::function_wrapper, QualityOfServiceClass};
 
+// TODO: Autogenerate with https://github.com/madsmtm/objc2/issues/609
+const DISPATCH_DATA_DESTRUCTOR_DEFAULT: dispatch_block_t = std::ptr::null_mut();
+
 /// Error returned by [DispatchObject::set_target_queue].
 #[derive(Debug, Copy, Clone, PartialEq, Eq, PartialOrd, Ord)]
 #[non_exhaustive]
@@ -60,6 +64,77 @@ impl<T> DispatchObject<T> {
         result
     }
 
+    /// Creates a dispatch data object with a copy of the given contiguous buffer of memory.
+    // TODO: Would it be safe for users to replace the finalizer?
+    pub fn data_create_copy(data: &[u8], queue: &Queue) -> Self {
+        // SAFETY: Buffer pointer is valid for the given number of bytes. Queue handle is valid,
+        // and the destructor is a NULL value which indicates the buffer should be copied.
+        let object = unsafe {
+            dispatch_data_create(
+                NonNull::new_unchecked(data.as_ptr().cast_mut()).cast(),
+                data.len(),
+                queue.as_raw(),
+                DISPATCH_DATA_DESTRUCTOR_DEFAULT,
+            )
+        };
+
+        Self {
+            object: object.cast(),
+            is_activated: false,
+        }
+    }
+
+    /// Creates a dispatch data object with a reference to the given contiguous buffer of memory.
+    pub fn data_create_static(data: &'static [u8], queue: &Queue) -> Self {
+        block2::global_block! {
+            static NOOP_BLOCK = || {}
+        }
+        // SAFETY: Buffer pointer is valid for the given number of bytes. Queue handle is valid,
+        // and the destructor is a NULL value which indicates the buffer should be copied.
+        let object = unsafe {
+            dispatch_data_create(
+                NonNull::new_unchecked(data.as_ptr().cast_mut()).cast(),
+                data.len(),
+                queue.as_raw(),
+                <*const _>::cast_mut(NOOP_BLOCK.deref()),
+            )
+        };
+
+        Self {
+            object: object.cast(),
+            is_activated: false,
+        }
+    }
+
+    /// Creates a dispatch data object with ownership of the given contiguous buffer of memory.
+    // TODO: Would it be safe for users to replace the finalizer?
+    pub fn data_create(data: Box<[u8]>, queue: &Queue) -> Self {
+        let data_len = data.len();
+        let raw = Box::into_raw(data);
+        let delete_box = block2::RcBlock::new(move || {
+            // SAFETY: The fat pointer (plus size) was retrieved from Box::into_raw(), and its
+            // ownership was *not* consumed by dispatch_data_create().
+            let _ = unsafe { Box::<[u8]>::from_raw(raw) };
+        });
+
+        // SAFETY: Buffer pointer is valid for the given number of bytes. Queue handle is valid,
+        // and the destructor is a NULL value which indicates the buffer should be copied.
+        // let t = Box::into_raw(data);
+        let object = unsafe {
+            dispatch_data_create(
+                NonNull::new_unchecked(raw).cast(),
+                data_len,
+                queue.as_raw(),
+                <*const _>::cast_mut(delete_box.deref()),
+            )
+        };
+
+        Self {
+            object: object.cast(),
+            is_activated: false,
+        }
+    }
+
     /// Set the finalizer function for the object.
     pub fn set_finalizer<F>(&mut self, destructor: F)
     where

crates/dispatch2/src/object.rs

@@ -127,7 +127,7 @@ pub struct Queue {
 }
 
 impl Queue {
-    /// Create a new [Queue].
+    /// Create a new [`Queue`].
     pub fn new(label: &str, queue_attribute: QueueAttribute) -> Self {
         let label = CString::new(label).expect("Invalid label!");
 
@@ -147,7 +147,7 @@ impl Queue {
         }
     }
 
-    /// Create a new [Queue] with a given target [Queue].
+    /// Create a new [`Queue`] with a given target [`Queue`].
     pub fn new_with_target(label: &str, queue_attribute: QueueAttribute, target: &Queue) -> Self {
         let label = CString::new(label).expect("Invalid label!");
 

crates/dispatch2/src/queue.rs

@@ -15,11 +15,6 @@ class.MTLRasterizationRateLayerDescriptor.methods.sampleCount.skipped = true
 # Swift also skips this.
 class.MTLRasterizationRateMapDescriptor.methods."rasterizationRateMapDescriptorWithScreenSize:layerCount:layers:".skipped = true
 
-# Needs dispatch
-class.MTLSharedEventListener.methods."initWithDispatchQueue:".skipped = true
-class.MTLSharedEventListener.methods.dispatchQueue.skipped = true
-protocol.MTLDevice.methods."newLibraryWithData:error:".skipped = true
-
 # Needs mach / kernel types
 protocol.MTLResource.methods."setOwnerWithIdentity:".skipped = true