pub trait FusedStream: Stream {
    fn is_terminated(&self) -> bool;
}
Expand description

A stream which tracks whether or not the underlying stream should no longer be polled.

is_terminated will return true if a future should no longer be polled. Usually, this state occurs after poll_next (or try_poll_next) returned Poll::Ready(None). However, is_terminated may also return true if a stream has become inactive and can no longer make progress and should be ignored or dropped rather than being polled again.

Required Methods

Returns true if the stream should no longer be polled.

Implementations on Foreign Types

Implementors

impl<T> FusedStream for Receiver<T>

impl<F> FusedStream for FlattenStream<F> where
    Flatten<F, <F as Future>::Output>: FusedStream,
    F: Future

impl<F> FusedStream for IntoStream<F> where
    Once<F>: FusedStream

impl<Fut> FusedStream for TryFlattenStream<Fut> where
    TryFlatten<Fut, Fut::Ok>: FusedStream,
    Fut: TryFuture

impl<Fut, Si> FusedStream for FlattenSink<Fut, Si> where
    TryFlatten<Fut, Si>: FusedStream

impl<A, B> FusedStream for Either<A, B> where
    A: FusedStream,
    B: FusedStream<Item = A::Item>, 

impl<St1, St2> FusedStream for Chain<St1, St2> where
    St1: Stream,
    St2: FusedStream<Item = St1::Item>, 

impl<St> FusedStream for Cycle<St> where
    St: Clone + Stream

impl<St, Fut, F> FusedStream for Filter<St, Fut, F> where
    St: Stream + FusedStream,
    F: FnMut(&St::Item) -> Fut,
    Fut: Future<Output = bool>, 

impl<St, Fut, F, T> FusedStream for FilterMap<St, Fut, F> where
    St: Stream + FusedStream,
    F: FnMut1<St::Item, Output = Fut>,
    Fut: Future<Output = Option<T>>, 

impl<St> FusedStream for Flatten<St> where
    Flatten<St, St::Item>: FusedStream,
    St: Stream

impl<S: Stream> FusedStream for Fuse<S>

impl<St, F> FusedStream for Inspect<St, F> where
    Map<St, InspectFn<F>>: FusedStream

impl<St, F> FusedStream for Map<St, F> where
    St: FusedStream,
    F: FnMut1<St::Item>, 

impl<St, U, F> FusedStream for FlatMap<St, U, F> where
    Flatten<Map<St, F>, U>: FusedStream

impl<St: Stream> FusedStream for Peekable<St>

impl<St: FusedStream> FusedStream for Skip<St>

impl<St, Fut, F> FusedStream for SkipWhile<St, Fut, F> where
    St: FusedStream,
    F: FnMut(&St::Item) -> Fut,
    Fut: Future<Output = bool>, 

impl<St> FusedStream for Take<St> where
    St: FusedStream

impl<St, Fut, F> FusedStream for TakeWhile<St, Fut, F> where
    St: FusedStream,
    F: FnMut(&St::Item) -> Fut,
    Fut: Future<Output = bool>, 

impl<St, Fut> FusedStream for TakeUntil<St, Fut> where
    St: Stream,
    Fut: Future

impl<St, Fut, F> FusedStream for Then<St, Fut, F> where
    St: FusedStream,
    F: FnMut(St::Item) -> Fut,
    Fut: Future

impl<St1, St2> FusedStream for Zip<St1, St2> where
    St1: Stream,
    St2: Stream

impl<St: FusedStream> FusedStream for Chunks<St>

impl<B, St, S, Fut, F> FusedStream for Scan<St, S, Fut, F> where
    St: FusedStream,
    F: FnMut(&mut S, St::Item) -> Fut,
    Fut: Future<Output = Option<B>>, 

impl<St> FusedStream for BufferUnordered<St> where
    St: Stream,
    St::Item: Future

impl<St, Fut, F> FusedStream for AndThen<St, Fut, F> where
    St: TryStream + FusedStream,
    F: FnMut(St::Ok) -> Fut,
    Fut: TryFuture<Error = St::Error>, 

impl<St, E> FusedStream for ErrInto<St, E> where
    MapErr<St, IntoFn<E>>: FusedStream

impl<St, F> FusedStream for InspectOk<St, F> where
    Inspect<IntoStream<St>, InspectOkFn<F>>: FusedStream

impl<St, F> FusedStream for InspectErr<St, F> where
    Inspect<IntoStream<St>, InspectErrFn<F>>: FusedStream

impl<St, F> FusedStream for MapOk<St, F> where
    Map<IntoStream<St>, MapOkFn<F>>: FusedStream

impl<St, F> FusedStream for MapErr<St, F> where
    Map<IntoStream<St>, MapErrFn<F>>: FusedStream

impl<St, Fut, F> FusedStream for OrElse<St, Fut, F> where
    St: TryStream + FusedStream,
    F: FnMut(St::Error) -> Fut,
    Fut: TryFuture<Ok = St::Ok>, 

impl<St, Fut, F> FusedStream for TryFilter<St, Fut, F> where
    St: TryStream + FusedStream,
    F: FnMut(&St::Ok) -> Fut,
    Fut: Future<Output = bool>, 

impl<St, Fut, F, T> FusedStream for TryFilterMap<St, Fut, F> where
    St: TryStream + FusedStream,
    Fut: TryFuture<Ok = Option<T>, Error = St::Error>,
    F: FnMut(St::Ok) -> Fut, 

impl<St> FusedStream for TryFlatten<St> where
    St: TryStream + FusedStream,
    St::Ok: TryStream,
    <St::Ok as TryStream>::Error: From<St::Error>, 

impl<St, Fut, F> FusedStream for TrySkipWhile<St, Fut, F> where
    St: TryStream + FusedStream,
    F: FnMut(&St::Ok) -> Fut,
    Fut: TryFuture<Ok = bool, Error = St::Error>, 

impl<St, Fut, F> FusedStream for TryTakeWhile<St, Fut, F> where
    St: TryStream + FusedStream,
    F: FnMut(&St::Ok) -> Fut,
    Fut: TryFuture<Ok = bool, Error = St::Error>, 

impl<T> FusedStream for Repeat<T> where
    T: Clone

impl<A, F: FnMut() -> A> FusedStream for RepeatWith<F>

impl<T> FusedStream for Empty<T>

impl<Fut: Future> FusedStream for Once<Fut>

impl<T> FusedStream for Pending<T>

impl<St1, St2> FusedStream for Select<St1, St2> where
    St1: Stream,
    St2: Stream<Item = St1::Item>, 

impl<T, F, Fut, Item> FusedStream for Unfold<T, F, Fut> where
    F: FnMut(T) -> Fut,
    Fut: Future<Output = Option<(Item, T)>>, 

impl<Fut: Future> FusedStream for FuturesOrdered<Fut>

impl<Fut: Future> FusedStream for FuturesUnordered<Fut>

impl<St: Stream + Unpin> FusedStream for SelectAll<St>

impl<S, Item, E> FusedStream for SinkErrInto<S, Item, E> where
    S: Sink<Item> + FusedStream,
    S::Error: Into<E>, 

impl<S: FusedStream, F> FusedStream for SinkMapErr<S, F>

impl<S, Item, U, St, F> FusedStream for WithFlatMap<S, Item, U, St, F> where
    S: FusedStream + Sink<Item>,
    F: FnMut(U) -> St,
    St: Stream<Item = Result<Item, S::Error>>, 

impl<S, Item> FusedStream for Buffer<S, Item> where
    S: Sink<Item> + FusedStream