Struct `AbortHandle`

pub struct AbortHandle { /* private fields */ }

A handle to an Abortable task.

Implementations

`impl AbortHandle`

fn abort(&self)

Abort the Abortable stream/future associated with this handle.

Notifies the Abortable task associated with this handle that it should abort. Note that if the task is currently being polled on another thread, it will not immediately stop running. Instead, it will continue to run until its poll method returns.

fn is_aborted(&self) -> bool

Checks whether AbortHandle::abort was called on any associated AbortHandles, which includes all the AbortHandles linked with the same AbortRegistration. This means that it will return true even if:

abort was called after the task had completed.
abort was called while the task was being polled - the task may still be running and will not be stopped until poll returns.

This operation has a Relaxed ordering.

`impl AbortHandle`

fn new_pair() -> (Self, AbortRegistration)

Creates an (AbortHandle, AbortRegistration) pair which can be used to abort a running future or stream.

This function is usually paired with a call to Abortable::new.

Trait Implementations

`impl Clone for AbortHandle`

fn clone(&self) -> AbortHandle

`impl Debug for AbortHandle`

fn fmt(&self, f: &mut Formatter<'_>) -> Result

Auto Trait Implementations

`impl !RefUnwindSafe for AbortHandle`

`impl !UnwindSafe for AbortHandle`

`impl Freeze for AbortHandle`

`impl Send for AbortHandle`

`impl Sync for AbortHandle`

`impl Unpin for AbortHandle`

`impl UnsafeUnpin for AbortHandle`

Blanket Implementations

`impl<T> Any for AbortHandle where T: 'static + ?Sized,`

fn type_id(&self) -> TypeId

`impl<T> Borrow<T> for AbortHandle where T: ?Sized,`

fn borrow(&self) -> &T

`impl<T> BorrowMut<T> for AbortHandle where T: ?Sized,`

fn borrow_mut(&mut self) -> &mut T

`impl<T> CloneToUninit for AbortHandle where T: Clone,`

unsafe fn clone_to_uninit(&self, dest: *mut u8)

`impl<T> From<T> for AbortHandle`

fn from(t: T) -> T: Returns the argument unchanged.

`impl<T> ToOwned for AbortHandle where T: Clone,`

type Owned = T;
fn to_owned(&self) -> T
fn clone_into(&self, target: &mut T)

`impl<T, U> Into<U> for AbortHandle where U: From<T>,`

fn into(self) -> U

Calls U::from(self).

That is, this conversion is whatever the implementation of [From]<T> for U chooses to do.

`impl<T, U> TryFrom<U> for AbortHandle where U: Into<T>,`

type Error = never;
fn try_from(value: U) -> Result<T, never>

`impl<T, U> TryInto<U> for AbortHandle where U: TryFrom<T>,`

type Error = <U as TryFrom<T>>::Error;
fn try_into(self) -> Result<U, <U as TryFrom<T>>::Error>