Struct StopAfterFuture

pub struct StopAfterFuture<S: Stream, Fut: Future> { /* private fields */ }

Stream for the [StreamExt::stop_after_future()] method.

Implementations

impl<St, Fut> StopAfterFuture<St, Fut>

where St: Stream, Fut: Future,

pub fn take_future(&mut self) -> Option<Fut>

Extract the stopping future out of the combinator.

The future is returned only if it isn’t resolved yet, ie. if the stream isn’t stopped yet. Taking out the future means the combinator will be yielding elements from the wrapped stream without ever stopping it.

pub fn take_result(&mut self) -> Option<Fut::Output>

Once the stopping future is resolved, this method can be used to extract the value returned by the stopping future.

This may be used to retrieve arbitrary data from the stopping future, for example a reason why the stream was stopped.

This method will return None if the future isn’t resolved yet, or if the result was already taken out.

Examples

use futures_lite::stream::{self, StreamExt, stop_after_future};
use futures_lite::future;
use std::task::Poll;

let stream = stream::iter(1..=10);

let mut i = 0;
let stop_fut = future::poll_fn(|_cx| {
    i += 1;
    if i <= 5 {
        Poll::Pending
    } else {
        Poll::Ready("reason")
    }
});

let mut stream = stop_after_future(stream, stop_fut);
let _ = (&mut stream).collect::<Vec<_>>().await;

let result = stream.take_result().unwrap();
assert_eq!(result, "reason");

pub fn is_stopped(&self) -> bool

Whether the stream was stopped yet by the stopping future being resolved.

Trait Implementations

impl<S: Clone + Stream, Fut: Clone + Future> Clone for StopAfterFuture<S, Fut>

where Fut::Output: Clone,

fn clone(&self) -> StopAfterFuture<S, Fut>

Returns a copy of the value.

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

Performs copy-assignment from source.

impl<S: Debug + Stream, Fut: Debug + Future> Debug for StopAfterFuture<S, Fut>

where Fut::Output: Debug,

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

Formats the value using the given formatter.

impl<St, Fut> Stream for StopAfterFuture<St, Fut>

where St: Stream, Fut: Future,

type Item = <St as Stream>::Item

Values yielded by the stream.

fn poll_next( self: Pin<&mut Self>, cx: &mut Context<'_>, ) -> Poll<Option<St::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, S: Stream, Fut: Future> Unpin for StopAfterFuture<S, Fut>

where PinnedFieldsOf<__Origin<'__pin, S, Fut>>: Unpin,