gio::prelude

Trait CancellableExtManual

Source 
pub trait CancellableExtManual: IsA<Cancellable> {
    // Provided methods
    fn connect_cancelled<F: FnOnce(&Self) + Send + 'static>(
        &self,
        callback: F,
    ) -> Option<CancelledHandlerId> { ... }
    fn connect_cancelled_local<F: FnOnce(&Self) + 'static>(
        &self,
        callback: F,
    ) -> Option<CancelledHandlerId> { ... }
    fn disconnect_cancelled(&self, id: CancelledHandlerId) { ... }
    fn future(
        &self,
    ) -> Pin<Box<dyn Future<Output = ()> + Send + Sync + 'static>> { ... }
    fn set_error_if_cancelled(&self) -> Result<(), Error> { ... }
}

Provided Methods§

Source

fn connect_cancelled<F: FnOnce(&Self) + Send + 'static>( &self, callback: F, ) -> Option<CancelledHandlerId>

Convenience function to connect to the signal::Cancellable::cancelled signal. Also handles the race condition that may happen if the cancellable is cancelled right before connecting. If the operation is cancelled from another thread, callback will be called in the thread that cancelled the operation, not the thread that is running the operation. This may be the main thread, so the callback should not do something that can block.

callback is called at most once, either directly at the time of the connect if self is already cancelled, or when self is cancelled in some thread.

Since GLib 2.40, the lock protecting self is not held when callback is invoked. This lifts a restriction in place for earlier GLib versions which now makes it easier to write cleanup code that unconditionally invokes e.g. CancellableExt::cancel().

§Returns

The id of the signal handler or None if self has already been cancelled.

Source

fn connect_cancelled_local<F: FnOnce(&Self) + 'static>( &self, callback: F, ) -> Option<CancelledHandlerId>

Local variant of Self::connect_cancelled.

Source

fn disconnect_cancelled(&self, id: CancelledHandlerId)

Disconnects a handler from a cancellable instance. Additionally, in the event that a signal handler is currently running, this call will block until the handler has finished. Calling this function from a callback registered with Self::connect_cancelled will therefore result in a deadlock.

This avoids a race condition where a thread cancels at the same time as the cancellable operation is finished and the signal handler is removed.

Source

fn future(&self) -> Pin<Box<dyn Future<Output = ()> + Send + Sync + 'static>>

Returns a Future that completes when the cancellable becomes cancelled. Completes immediately if the cancellable is already cancelled.

Source

fn set_error_if_cancelled(&self) -> Result<(), Error>

Set an error if the cancellable is already cancelled. If the @self is cancelled, sets the error to notify that the operation was cancelled.

§Returns

true if @self was cancelled, false if it was not

Dyn Compatibility§

This trait is not dyn compatible.

In older versions of Rust, dyn compatibility was called "object safety", so this trait is not object safe.

Implementors§