|
1 | 1 | // Take a look at the license at the top of the repository in the LICENSE file. |
2 | 2 |
|
3 | 3 | use crate::prelude::*; |
| 4 | +use crate::Cancellable; |
| 5 | +use glib::{translate::*, IsA}; |
| 6 | +use std::num::NonZeroU64; |
4 | 7 |
|
5 | | -#[test] |
6 | | -fn check_callback() { |
7 | | - let c = crate::Cancellable::new(); |
8 | | - c.connect_cancelled(|_| {}); |
9 | | - c.cancel(); // if it doesn't crash at this point, then we're good to go! |
| 8 | +// rustdoc-stripper-ignore-next |
| 9 | +/// The id of a cancelled handler that is returned by `CancellableExtManual::connect`. This type is |
| 10 | +/// analogous to [`glib::SignalHandlerId`]. |
| 11 | +#[derive(Debug, Eq, PartialEq)] |
| 12 | +#[repr(transparent)] |
| 13 | +pub struct CancelledHandlerId(NonZeroU64); |
| 14 | + |
| 15 | +impl CancelledHandlerId { |
| 16 | + // rustdoc-stripper-ignore-next |
| 17 | + /// Returns the internal signal handler ID. |
| 18 | + pub unsafe fn as_raw(&self) -> libc::c_ulong { |
| 19 | + self.0.get() as libc::c_ulong |
| 20 | + } |
| 21 | +} |
| 22 | + |
| 23 | +impl TryFromGlib<libc::c_ulong> for CancelledHandlerId { |
| 24 | + type Error = GlibNoneError; |
| 25 | + #[inline] |
| 26 | + unsafe fn try_from_glib(val: libc::c_ulong) -> Result<Self, GlibNoneError> { |
| 27 | + NonZeroU64::new(val as u64).map(Self).ok_or(GlibNoneError) |
| 28 | + } |
| 29 | +} |
| 30 | + |
| 31 | +pub trait CancellableExtManual { |
| 32 | + // rustdoc-stripper-ignore-next |
| 33 | + /// Convenience function to connect to the `signal::Cancellable::cancelled` signal. Also |
| 34 | + /// handles the race condition that may happen if the cancellable is cancelled right before |
| 35 | + /// connecting. If the operation is cancelled from another thread, `callback` will be called |
| 36 | + /// in the thread that cancelled the operation, not the thread that is running the operation. |
| 37 | + /// This may be the main thread, so the callback should not do something that can block. |
| 38 | + /// |
| 39 | + /// `callback` is called at most once, either directly at the time of the connect if `self` is |
| 40 | + /// already cancelled, or when `self` is cancelled in some thread. |
| 41 | + /// |
| 42 | + /// Since GLib 2.40, the lock protecting `self` is not held when `callback` is invoked. This |
| 43 | + /// lifts a restriction in place for earlier GLib versions which now makes it easier to write |
| 44 | + /// cleanup code that unconditionally invokes e.g. |
| 45 | + /// [`CancellableExt::cancel()`][crate::prelude::CancellableExt::cancel()]. |
| 46 | + /// |
| 47 | + /// # Returns |
| 48 | + /// |
| 49 | + /// The id of the signal handler or `None` if `self` has already been cancelled. |
| 50 | + #[doc(alias = "g_cancellable_connect")] |
| 51 | + fn connect_cancelled<F: FnOnce(&Self) + Send + 'static>( |
| 52 | + &self, |
| 53 | + callback: F, |
| 54 | + ) -> Option<CancelledHandlerId>; |
| 55 | + // rustdoc-stripper-ignore-next |
| 56 | + /// Disconnects a handler from a cancellable instance. Additionally, in the event that a signal |
| 57 | + /// handler is currently running, this call will block until the handler has finished. Calling |
| 58 | + /// this function from a callback registered with [`Self::connect_cancelled`] will therefore |
| 59 | + /// result in a deadlock. |
| 60 | + /// |
| 61 | + /// This avoids a race condition where a thread cancels at the same time as the cancellable |
| 62 | + /// operation is finished and the signal handler is removed. |
| 63 | + #[doc(alias = "g_cancellable_disconnect")] |
| 64 | + fn disconnect_cancelled(&self, id: CancelledHandlerId); |
| 65 | +} |
| 66 | + |
| 67 | +impl<O: IsA<Cancellable>> CancellableExtManual for O { |
| 68 | + #[doc(alias = "g_cancellable_connect")] |
| 69 | + fn connect_cancelled<F: FnOnce(&Self) + Send + 'static>( |
| 70 | + &self, |
| 71 | + callback: F, |
| 72 | + ) -> Option<CancelledHandlerId> { |
| 73 | + unsafe extern "C" fn connect_trampoline<P: IsA<Cancellable>, F: FnOnce(&P)>( |
| 74 | + this: *mut ffi::GCancellable, |
| 75 | + callback: glib::ffi::gpointer, |
| 76 | + ) { |
| 77 | + let callback: &mut Option<F> = &mut *(callback as *mut Option<F>); |
| 78 | + let callback = callback |
| 79 | + .take() |
| 80 | + .expect("Cancellable::cancel() closure called multiple times"); |
| 81 | + callback(Cancellable::from_glib_borrow(this).unsafe_cast_ref()) |
| 82 | + } |
| 83 | + |
| 84 | + unsafe extern "C" fn destroy_closure<F>(ptr: glib::ffi::gpointer) { |
| 85 | + Box::<Option<F>>::from_raw(ptr as *mut _); |
| 86 | + } |
| 87 | + |
| 88 | + let callback: Box<Option<F>> = Box::new(Some(callback)); |
| 89 | + unsafe { |
| 90 | + from_glib(ffi::g_cancellable_connect( |
| 91 | + self.as_ptr() as *mut _, |
| 92 | + Some(std::mem::transmute::<_, unsafe extern "C" fn()>( |
| 93 | + connect_trampoline::<Self, F> as *const (), |
| 94 | + )), |
| 95 | + Box::into_raw(callback) as *mut _, |
| 96 | + Some(destroy_closure::<F>), |
| 97 | + )) |
| 98 | + } |
| 99 | + } |
| 100 | + #[doc(alias = "g_cancellable_disconnect")] |
| 101 | + fn disconnect_cancelled(&self, id: CancelledHandlerId) { |
| 102 | + unsafe { ffi::g_cancellable_disconnect(self.as_ptr() as *mut _, id.as_raw()) }; |
| 103 | + } |
| 104 | +} |
| 105 | + |
| 106 | +#[cfg(test)] |
| 107 | +mod tests { |
| 108 | + use super::*; |
| 109 | + |
| 110 | + #[test] |
| 111 | + fn cancellable_callback() { |
| 112 | + let c = Cancellable::new(); |
| 113 | + let id = c.connect_cancelled(|_| {}); |
| 114 | + c.cancel(); // if it doesn't crash at this point, then we're good to go! |
| 115 | + c.disconnect_cancelled(id.unwrap()); |
| 116 | + } |
10 | 117 | } |
0 commit comments