Trait StreamExt

pub trait StreamExt: Stream + Sized {
    // Provided methods
    fn into_boxed(self) -> BoxStream<Self::Item, Self::Error>
       where Self: 'static { ... }
    fn into_send_boxed(self) -> BoxSendStream<Self::Item, Self::Error>
       where Self: Send + 'static { ... }
    fn until<C>(self, condition: C) -> Until<Self, C>
       where C: Future<Item = ()>,
             Self::Error: From<C::Error> { ... }
    fn first_ok(self) -> FirstOk<Self> { ... }
    fn log_errors(
        self,
        level: LogLevel,
        description: &'static str,
    ) -> LogErrors<Self>
       where Self::Error: Display { ... }
    fn infallible<E>(self) -> Infallible<Self, E>
       where Self: Stream<Error = Void> { ... }
    fn next_or_else<F, E>(self, f: F) -> NextOrElse<Self, F>
       where F: FnOnce() -> E,
             E: From<Self::Error> { ... }
    fn finally<D>(self, on_drop: D) -> Finally<Self, D>
       where D: FnOnce() { ... }
    fn with_timeout(self, duration: Duration) -> WithTimeout<Self> { ... }
    fn with_timeout_at(self, instant: Instant) -> WithTimeout<Self> { ... }
    fn with_readiness_timeout(
        self,
        duration: Duration,
    ) -> WithReadinessTimeout<Self> { ... }
}

Extension trait for Stream.

Provided Methods

fn into_boxed(self) -> BoxStream<Self::Item, Self::Error>

where Self: 'static,

Wraps a stream into a boxed stream, making type-checking easier at the expense of an extra layer of indirection at runtime.

fn into_send_boxed(self) -> BoxSendStream<Self::Item, Self::Error>

where Self: Send + 'static,

fn until<C>(self, condition: C) -> Until<Self, C>

where C: Future<Item = ()>, Self::Error: From<C::Error>,

Run this stream until some condition is met. condition is a future which returns (), after which this stream will be finished.

Example

let my_stream_with_timeout = my_stream.until(Delay::new(Instant::now() + Duration::from_secs(1)));

fn first_ok(self) -> FirstOk<Self>

Adapts a stream to a future by taking the first successful item yielded by the stream. If the stream ends before yielding an Ok then all the errors that were yielded by the stream are returned in a vector.

fn log_errors( self, level: LogLevel, description: &'static str, ) -> LogErrors<Self>

where Self::Error: Display,

Removes the errors from this stream and log them. description is prepended to the log messages. The returned stream has error type Void since the errors have been removed.

fn infallible<E>(self) -> Infallible<Self, E>

where Self: Stream<Error = Void>,

For streams which can’t fail (ie. which have error type Void), cast the error type to some inferred type.

fn next_or_else<F, E>(self, f: F) -> NextOrElse<Self, F>

where F: FnOnce() -> E, E: From<Self::Error>,

Returns a future which returns the next item from the stream, along with the stream itself. If the stream errors then just the error is returned. If the stream ends then the provided closure is used to produce an error value.

fn finally<D>(self, on_drop: D) -> Finally<Self, D>

where D: FnOnce(),

Yields items from the stream and runs the provided callback when the stream finishes. The callback will also be run if the entire stream is dropped.

fn with_timeout(self, duration: Duration) -> WithTimeout<Self>

Runs the stream for the given duration.

fn with_timeout_at(self, instant: Instant) -> WithTimeout<Self>

Runs the stream until the given timeout.

fn with_readiness_timeout( self, duration: Duration, ) -> WithReadinessTimeout<Self>

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

impl<T: Stream + Sized> StreamExt for T