Trait future_utils::StreamExt[−][src]

pub trait StreamExt: Stream + Sized {
    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

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

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)));

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.

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.

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

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.

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.

Runs the stream for the given duration.

Runs the stream until the given timeout.

Implementors