Trait tokio::prelude::StreamExt

pub trait StreamExt: Stream {
    fn throttle(self, duration: Duration) -> Throttle<Self>
    where
        Self: Sized,
    { ... }
    fn enumerate(self) -> Enumerate<Self>
    where
        Self: Sized,
    { ... }
    fn timeout(self, timeout: Duration) -> Timeout<Self>
    where
        Self: Sized,
    { ... }
}

An extension trait for Stream that provides a variety of convenient combinator functions.

Currently, there only is a timeout function, but this will increase over time.

Users are not expected to implement this trait. All types that implement Stream already implement StreamExt.

This trait can be imported directly or via the Tokio prelude: use tokio::prelude::*.

Provided methods

fn throttle(self, duration: Duration) -> Throttle<Self> where
    Self: Sized, 

Throttle down the stream by enforcing a fixed delay between items.

Errors are also delayed.

fn enumerate(self) -> Enumerate<Self> where
    Self: Sized, 

Creates a new stream which gives the current iteration count as well as the next value.

The stream returned yields pairs (i, val), where i is the current index of iteration and val is the value returned by the iterator.

Overflow Behavior

The method does no guarding against overflows, so counting elements of an iterator with more than std::usize::MAX elements either produces the wrong result or panics.

fn timeout(self, timeout: Duration) -> Timeout<Self> where
    Self: Sized, 

Creates a new stream which allows self until timeout.

This combinator creates a new stream which wraps the receiving stream with a timeout. For each item, the returned stream is allowed to execute until it completes or timeout has elapsed, whichever happens first.

If an item completes before timeout then the stream will yield with that item. Otherwise the stream will yield to an error.

Examples

use tokio::prelude::*;
use std::time::Duration;

let stream = long_future()
    .into_stream()
    .timeout(Duration::from_secs(1))
    .for_each(|i| future::ok(println!("item = {:?}", i)))
    .map_err(|e| println!("error = {:?}", e));

tokio::run(stream);

Loading content...

Implementors

impl<T: ?Sized> StreamExt for T where     T: Stream,

fn throttle(self, duration: Duration) -> Throttle<Self> where     Self: Sized,

fn enumerate(self) -> Enumerate<Self> where     Self: Sized,

fn timeout(self, timeout: Duration) -> Timeout<Self> where     Self: Sized,

Loading content...