Rename some Dispatch types to match Swift

DispatchTime, DispatchQoS, DispatchAutoReleaseFrequency, DispatchBlock,
and a few DispatchIO* types.

At the same time, remove the `dispatch2::ffi` module, it is now mostly
redundant, and it's a bad idea to split the API in two like this: we
should instead work towards mapping everything, so that there isn't a
need!

Part of #77.

Author: madsmtm

crates/dispatch2/TODO.md

@@ -9,3 +9,14 @@
 - Safe wrapper for ``dispatch_get_context/dispatch_set_context`` (quite impossible without big overhead => wrap dispatch object destructor to release the boxed value)
 - All blocks related bindings and ``dispatch_block_*`` functions with compat with ``block2`` on Apple platforms.
 - Integrate conversion from SystemTime to dispatch_time_t via dispatch_walltime and safe APIs using that.
+- `dispatch/introspection.h`
+
+
+NOTES:
+- suspended object must not be released
+  - Closure?
+  - Resume drop guard (that holds a reference count, ensuring not releasing even if leaked)
+  - Activation: "Releasing the last reference count on an inactive object is undefined."
+- Rename `DispatchQoS` etc. to fit Swift naming
+
+- Dispatch blocks

crates/dispatch2/src/ffi.rs

@@ -1,11 +1,11 @@
 use alloc::boxed::Box;
 use core::ffi::c_void;
-use core::time::Duration;
 
-use crate::{DispatchObject, DispatchQueue, DispatchRetained};
+use crate::generated::{dispatch_group_enter, dispatch_group_wait};
+use crate::{DispatchObject, DispatchQueue, DispatchRetained, DispatchTime};
 
 use super::utils::function_wrapper;
-use super::{ffi::*, WaitError};
+use super::WaitError;
 
 dispatch_object!(
     /// Dispatch group.
@@ -34,16 +34,8 @@ impl DispatchGroup {
     ///
     /// # Errors
     ///
-    /// Return [WaitError::TimeOverflow] if the passed ``timeout`` is too big.
-    ///
     /// Return [WaitError::Timeout] in case of timeout.
-    pub fn wait(&self, timeout: Option<Duration>) -> Result<(), WaitError> {
-        let timeout = if let Some(timeout) = timeout {
-            dispatch_time_t::try_from(timeout).map_err(|_| WaitError::TimeOverflow)?
-        } else {
-            DISPATCH_TIME_FOREVER
-        };
-
+    pub fn wait(&self, timeout: DispatchTime) -> Result<(), WaitError> {
         let result = dispatch_group_wait(self, timeout);
 
         match result {

crates/dispatch2/src/group.rs

@@ -1,3 +1,6 @@
+#![allow(missing_docs)] // TODO
+use core::ffi::{c_long, c_ulong};
+
 dispatch_object!(
     /// Dispatch IO.
     #[doc(alias = "dispatch_io_t")]
@@ -6,3 +9,28 @@ dispatch_object!(
 );
 
 dispatch_object_not_data!(unsafe DispatchIO);
+
+enum_with_val! {
+    #[doc(alias = "dispatch_io_type_t")]
+    #[derive(PartialEq, Eq, Clone, Copy)]
+    pub struct DispatchIOStreamType(pub c_ulong) {
+        DISPATCH_IO_STREAM = 0,
+        DISPATCH_IO_RANDOM = 1,
+    }
+}
+
+enum_with_val! {
+    #[doc(alias = "dispatch_io_close_flags_t")]
+    #[derive(PartialEq, Eq, Clone, Copy)]
+    pub struct DispatchIOCloseFlags(pub c_ulong) {
+        DISPATCH_IO_STOP = 0x1,
+    }
+}
+
+enum_with_val! {
+    #[doc(alias = "dispatch_io_interval_flags_t")]
+    #[derive(PartialEq, Eq, Clone, Copy)]
+    pub struct DispatchIOIntervalFlags(pub c_long) {
+        DISPATCH_IO_STRICT_INTERVAL = 0x1,
+    }
+}