gio: implement DatagramBased

jf2048 · jf2048 · commit 3a880a959ae4 · 2022-11-30T14:47:31.000-05:00
diff --git a/gio/Gir.toml b/gio/Gir.toml
@@ -451,6 +451,31 @@ status = "generate"
     name = "win32_pid"
     version = "2.72"
 
+[[object]]
+name = "Gio.DatagramBased"
+status = "generate"
+manual_traits = ["DatagramBasedExtManual"]
+    [[object.function]]
+    name = "condition_wait"
+    # needs Duration
+    manual = true
+    doc_trait_name = "DatagramBasedExtManual"
+    [[object.function]]
+    name = "create_source"
+    # manual source implementation
+    manual = true
+    doc_trait_name = "DatagramBasedExtManual"
+    [[object.function]]
+    name = "receive_messages"
+    # InputMessage is not a gtype
+    manual = true
+    doc_trait_name = "DatagramBasedExtManual"
+    [[object.function]]
+    name = "send_messages"
+    # OutputMessage is not a gtype
+    manual = true
+    doc_trait_name = "DatagramBasedExtManual"
+
 [[object]]
 name = "Gio.DataInputStream"
 manual_traits = ["DataInputStreamExtManual"]
diff --git a/gio/src/auto/datagram_based.rs b/gio/src/auto/datagram_based.rs
@@ -0,0 +1,42 @@
+// This file was generated by gir (https://github.com/gtk-rs/gir)
+// from gir-files (https://github.com/gtk-rs/gir-files)
+// DO NOT EDIT
+
+use glib::object::IsA;
+use glib::translate::*;
+use std::fmt;
+
+glib::wrapper! {
+    #[doc(alias = "GDatagramBased")]
+    pub struct DatagramBased(Interface<ffi::GDatagramBased, ffi::GDatagramBasedInterface>);
+
+    match fn {
+        type_ => || ffi::g_datagram_based_get_type(),
+    }
+}
+
+impl DatagramBased {
+    pub const NONE: Option<&'static DatagramBased> = None;
+}
+
+pub trait DatagramBasedExt: 'static {
+    #[doc(alias = "g_datagram_based_condition_check")]
+    fn condition_check(&self, condition: glib::IOCondition) -> glib::IOCondition;
+}
+
+impl<O: IsA<DatagramBased>> DatagramBasedExt for O {
+    fn condition_check(&self, condition: glib::IOCondition) -> glib::IOCondition {
+        unsafe {
+            from_glib(ffi::g_datagram_based_condition_check(
+                self.as_ref().to_glib_none().0,
+                condition.into_glib(),
+            ))
+        }
+    }
+}
+
+impl fmt::Display for DatagramBased {
+    fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
+        f.write_str("DatagramBased")
+    }
+}
diff --git a/gio/src/auto/mod.rs b/gio/src/auto/mod.rs
@@ -98,6 +98,9 @@ pub use self::data_input_stream::DataInputStream;
 mod data_output_stream;
 pub use self::data_output_stream::DataOutputStream;
 
+mod datagram_based;
+pub use self::datagram_based::DatagramBased;
+
 #[cfg(any(feature = "v2_72", feature = "dox"))]
 #[cfg_attr(feature = "dox", doc(cfg(feature = "v2_72")))]
 mod debug_controller;
@@ -387,6 +390,7 @@ mod unix_fd_message;
 #[cfg(any(unix, feature = "dox"))]
 #[cfg_attr(feature = "dox", doc(cfg(unix)))]
 pub use self::unix_fd_message::UnixFDMessage;
+
 #[cfg(any(unix, feature = "dox"))]
 #[cfg_attr(feature = "dox", doc(cfg(unix)))]
 mod unix_input_stream;
@@ -723,6 +727,7 @@ pub mod traits {
     pub use super::converter_output_stream::ConverterOutputStreamExt;
     pub use super::data_input_stream::DataInputStreamExt;
     pub use super::data_output_stream::DataOutputStreamExt;
+    pub use super::datagram_based::DatagramBasedExt;
     pub use super::dbus_interface::DBusInterfaceExt;
     pub use super::dbus_interface_skeleton::DBusInterfaceSkeletonExt;
     pub use super::dbus_object::DBusObjectExt;
diff --git a/gio/src/auto/socket.rs b/gio/src/auto/socket.rs
@@ -4,6 +4,7 @@
 
 use crate::Cancellable;
 use crate::Credentials;
+use crate::DatagramBased;
 use crate::InetAddress;
 use crate::Initable;
 use crate::SocketAddress;
@@ -25,7 +26,7 @@ use std::ptr;
 
 glib::wrapper! {
     #[doc(alias = "GSocket")]
-    pub struct Socket(Object<ffi::GSocket, ffi::GSocketClass>) @implements Initable;
+    pub struct Socket(Object<ffi::GSocket, ffi::GSocketClass>) @implements DatagramBased, Initable;
 
     match fn {
         type_ => || ffi::g_socket_get_type(),
diff --git a/gio/src/datagram_based.rs b/gio/src/datagram_based.rs
@@ -0,0 +1,266 @@
+// Take a look at the license at the top of the repository in the LICENSE file.
+
+use crate::Cancellable;
+use crate::DatagramBased;
+use crate::InputMessage;
+use crate::OutputMessage;
+use futures_core::stream::Stream;
+use glib::object::{Cast, IsA};
+use glib::translate::*;
+use std::cell::RefCell;
+use std::mem::transmute;
+use std::pin::Pin;
+use std::ptr;
+use std::time::Duration;
+
+pub trait DatagramBasedExtManual: Sized {
+    #[doc(alias = "g_datagram_based_create_source")]
+    fn create_source<F, C>(
+        &self,
+        condition: glib::IOCondition,
+        cancellable: Option<&C>,
+        name: Option<&str>,
+        priority: glib::Priority,
+        func: F,
+    ) -> glib::Source
+    where
+        F: FnMut(&Self, glib::IOCondition) -> glib::Continue + 'static,
+        C: IsA<Cancellable>;
+
+    fn create_source_future<C: IsA<Cancellable>>(
+        &self,
+        condition: glib::IOCondition,
+        cancellable: Option<&C>,
+        priority: glib::Priority,
+    ) -> Pin<Box<dyn std::future::Future<Output = glib::IOCondition> + 'static>>;
+
+    fn create_source_stream<C: IsA<Cancellable>>(
+        &self,
+        condition: glib::IOCondition,
+        cancellable: Option<&C>,
+        priority: glib::Priority,
+    ) -> Pin<Box<dyn Stream<Item = glib::IOCondition> + 'static>>;
+
+    #[doc(alias = "g_datagram_based_condition_wait")]
+    fn condition_wait(
+        &self,
+        condition: glib::IOCondition,
+        timeout: Option<Duration>,
+        cancellable: Option<&impl IsA<Cancellable>>,
+    ) -> Result<(), glib::Error>;
+
+    #[doc(alias = "g_datagram_based_receive_messages")]
+    fn receive_messages<'v, V: IntoIterator<Item = &'v mut [&'v mut [u8]]>, C: IsA<Cancellable>>(
+        &self,
+        messages: &mut [InputMessage],
+        flags: i32,
+        timeout: Option<Duration>,
+        cancellable: Option<&C>,
+    ) -> Result<usize, glib::Error>;
+
+    #[doc(alias = "g_datagram_based_send_messages")]
+    fn send_messages<C: IsA<Cancellable>>(
+        &self,
+        messages: &mut [OutputMessage],
+        flags: i32,
+        timeout: Option<Duration>,
+        cancellable: Option<&C>,
+    ) -> Result<usize, glib::Error>;
+}
+
+impl<O: IsA<DatagramBased>> DatagramBasedExtManual for O {
+    fn create_source<F, C>(
+        &self,
+        condition: glib::IOCondition,
+        cancellable: Option<&C>,
+        name: Option<&str>,
+        priority: glib::Priority,
+        func: F,
+    ) -> glib::Source
+    where
+        F: FnMut(&Self, glib::IOCondition) -> glib::Continue + 'static,
+        C: IsA<Cancellable>,
+    {
+        unsafe extern "C" fn trampoline<
+            O: IsA<DatagramBased>,
+            F: FnMut(&O, glib::IOCondition) -> glib::Continue + 'static,
+        >(
+            datagram_based: *mut ffi::GDatagramBased,
+            condition: glib::ffi::GIOCondition,
+            func: glib::ffi::gpointer,
+        ) -> glib::ffi::gboolean {
+            let func: &RefCell<F> = &*(func as *const RefCell<F>);
+            let mut func = func.borrow_mut();
+            (*func)(
+                DatagramBased::from_glib_borrow(datagram_based).unsafe_cast_ref(),
+                from_glib(condition),
+            )
+            .into_glib()
+        }
+        unsafe extern "C" fn destroy_closure<O, F>(ptr: glib::ffi::gpointer) {
+            let _ = Box::<RefCell<F>>::from_raw(ptr as *mut _);
+        }
+        let cancellable = cancellable.map(|c| c.as_ref());
+        let gcancellable = cancellable.to_glib_none();
+        unsafe {
+            let source = ffi::g_datagram_based_create_source(
+                self.as_ref().to_glib_none().0,
+                condition.into_glib(),
+                gcancellable.0,
+            );
+            let trampoline = trampoline::<O, F> as glib::ffi::gpointer;
+            glib::ffi::g_source_set_callback(
+                source,
+                Some(transmute::<
+                    _,
+                    unsafe extern "C" fn(glib::ffi::gpointer) -> glib::ffi::gboolean,
+                >(trampoline)),
+                Box::into_raw(Box::new(RefCell::new(func))) as glib::ffi::gpointer,
+                Some(destroy_closure::<O, F>),
+            );
+            glib::ffi::g_source_set_priority(source, priority.into_glib());
+
+            if let Some(name) = name {
+                glib::ffi::g_source_set_name(source, name.to_glib_none().0);
+            }
+
+            from_glib_full(source)
+        }
+    }
+
+    fn create_source_future<C: IsA<Cancellable>>(
+        &self,
+        condition: glib::IOCondition,
+        cancellable: Option<&C>,
+        priority: glib::Priority,
+    ) -> Pin<Box<dyn std::future::Future<Output = glib::IOCondition> + 'static>> {
+        let cancellable: Option<Cancellable> = cancellable.map(|c| c.as_ref()).cloned();
+
+        let obj = self.clone();
+        Box::pin(glib::SourceFuture::new(move |send| {
+            let mut send = Some(send);
+            obj.create_source(
+                condition,
+                cancellable.as_ref(),
+                None,
+                priority,
+                move |_, condition| {
+                    let _ = send.take().unwrap().send(condition);
+                    glib::Continue(false)
+                },
+            )
+        }))
+    }
+
+    fn create_source_stream<C: IsA<Cancellable>>(
+        &self,
+        condition: glib::IOCondition,
+        cancellable: Option<&C>,
+        priority: glib::Priority,
+    ) -> Pin<Box<dyn Stream<Item = glib::IOCondition> + 'static>> {
+        let cancellable: Option<Cancellable> = cancellable.map(|c| c.as_ref()).cloned();
+
+        let obj = self.clone();
+        Box::pin(glib::SourceStream::new(move |send| {
+            let send = Some(send);
+            obj.create_source(
+                condition,
+                cancellable.as_ref(),
+                None,
+                priority,
+                move |_, condition| {
+                    if send.as_ref().unwrap().unbounded_send(condition).is_err() {
+                        glib::Continue(false)
+                    } else {
+                        glib::Continue(true)
+                    }
+                },
+            )
+        }))
+    }
+
+    fn condition_wait(
+        &self,
+        condition: glib::IOCondition,
+        timeout: Option<Duration>,
+        cancellable: Option<&impl IsA<Cancellable>>,
+    ) -> Result<(), glib::Error> {
+        unsafe {
+            let mut error = ptr::null_mut();
+            let is_ok = ffi::g_datagram_based_condition_wait(
+                self.as_ref().to_glib_none().0,
+                condition.into_glib(),
+                timeout
+                    .map(|t| t.as_micros().try_into().unwrap())
+                    .unwrap_or(-1),
+                cancellable.map(|p| p.as_ref()).to_glib_none().0,
+                &mut error,
+            );
+            assert_eq!(is_ok == glib::ffi::GFALSE, !error.is_null());
+            if error.is_null() {
+                Ok(())
+            } else {
+                Err(from_glib_full(error))
+            }
+        }
+    }
+
+    fn receive_messages<'v, V: IntoIterator<Item = &'v mut [&'v mut [u8]]>, C: IsA<Cancellable>>(
+        &self,
+        messages: &mut [InputMessage],
+        flags: i32,
+        timeout: Option<Duration>,
+        cancellable: Option<&C>,
+    ) -> Result<usize, glib::Error> {
+        let cancellable = cancellable.map(|c| c.as_ref());
+        unsafe {
+            let mut error = ptr::null_mut();
+
+            let count = ffi::g_datagram_based_receive_messages(
+                self.as_ref().to_glib_none().0,
+                messages.as_mut_ptr() as *mut _,
+                messages.len().try_into().unwrap(),
+                flags,
+                timeout
+                    .map(|t| t.as_micros().try_into().unwrap())
+                    .unwrap_or(-1),
+                cancellable.to_glib_none().0,
+                &mut error,
+            );
+            if error.is_null() {
+                Ok(count as usize)
+            } else {
+                Err(from_glib_full(error))
+            }
+        }
+    }
+
+    fn send_messages<C: IsA<Cancellable>>(
+        &self,
+        messages: &mut [OutputMessage],
+        flags: i32,
+        timeout: Option<Duration>,
+        cancellable: Option<&C>,
+    ) -> Result<usize, glib::Error> {
+        let cancellable = cancellable.map(|c| c.as_ref());
+        unsafe {
+            let mut error = ptr::null_mut();
+            let count = ffi::g_datagram_based_send_messages(
+                self.as_ref().to_glib_none().0,
+                messages.as_mut_ptr() as *mut _,
+                messages.len().try_into().unwrap(),
+                flags,
+                timeout
+                    .map(|t| t.as_micros().try_into().unwrap())
+                    .unwrap_or(-1),
+                cancellable.to_glib_none().0,
+                &mut error,
+            );
+            if error.is_null() {
+                Ok(count as usize)
+            } else {
+                Err(from_glib_full(error))
+            }
+        }
+    }
+}
diff --git a/gio/src/lib.rs b/gio/src/lib.rs
@@ -25,6 +25,7 @@ pub use crate::cancellable_future::CancellableFuture;
 pub use crate::cancellable_future::Cancelled;
 mod converter;
 mod data_input_stream;
+mod datagram_based;
 mod dbus;
 pub use self::dbus::*;
 mod dbus_connection;
diff --git a/gio/src/prelude.rs b/gio/src/prelude.rs
