Struct futures::prelude::stream::Abortable

pub struct Abortable<T> { /* private fields */ }

A future/stream which can be remotely short-circuited using an AbortHandle.

Implementations

impl<T> Abortable<T>

pub fn new(task: T, reg: AbortRegistration) -> Abortable<T>

Creates a new Abortable future/stream using an existing AbortRegistration. AbortRegistrations can be acquired through AbortHandle::new.

When abort is called on the handle tied to reg or if abort has already been called, the future/stream will complete immediately without making any further progress.

Examples:

Usage with futures:

use futures::future::{Abortable, AbortHandle, Aborted};

let (abort_handle, abort_registration) = AbortHandle::new_pair();
let future = Abortable::new(async { 2 }, abort_registration);
abort_handle.abort();
assert_eq!(future.await, Err(Aborted));

Usage with streams:

let (abort_handle, abort_registration) = AbortHandle::new_pair();
let mut stream = Abortable::new(stream::iter(vec![1, 2, 3]), abort_registration);
abort_handle.abort();
assert_eq!(stream.next().await, None);

pub fn is_aborted(&self) -> bool

Checks whether the task has been aborted. Note that all this method indicates is whether AbortHandle::abort was called. 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.

Trait Implementations

impl<T> Clone for Abortable<T> where
    T: Clone, 

pub fn clone(&self) -> Abortable<T>

Returns a copy of the value.

fn clone_from(&mut self, source: &Self)

Performs copy-assignment from source.

impl<T> Debug for Abortable<T> where
    T: Debug, 

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

Formats the value using the given formatter.

impl<Fut> Future for Abortable<Fut> where
    Fut: Future, 

type Output = Result<<Fut as Future>::Output, Aborted>

The type of value produced on completion.

pub fn poll(
    self: Pin<&mut Abortable<Fut>>,
    cx: &mut Context<'_>
) -> Poll<<Abortable<Fut> as Future>::Output>

Attempt to resolve the future to a final value, registering the current task for wakeup if the value is not yet available.

impl<St> Stream for Abortable<St> where
    St: Stream, 

type Item = <St as Stream>::Item

Values yielded by the stream.

pub fn poll_next(
    self: Pin<&mut Abortable<St>>,
    cx: &mut Context<'_>
) -> Poll<Option<<Abortable<St> as Stream>::Item>>

Attempt to pull out the next value of this stream, registering the current task for wakeup if the value is not yet available, and returning None if the stream is exhausted.

fn size_hint(&self) -> (usize, Option<usize>)

Returns the bounds on the remaining length of the stream.

impl<'__pin, T> Unpin for Abortable<T> where
    __Origin<'__pin, T>: Unpin,