Struct DataStream 

pub struct DataStream<T> { /* private fields */ }

Each stage has at most 32 queued values; dropping a consumer stops its producer.

Implementations

impl<T: Send + 'static> DataStream<T>

pub fn from_values<I>(values: I) -> Self

where I: IntoIterator<Item = T> + Send + 'static, I::IntoIter: Send,

pub async fn next(&mut self) -> Option<T>

pub fn map<U, F>(self, transform: F) -> DataStream<U>

where U: Send + 'static, F: FnMut(T) -> U + Send + 'static,

pub fn map_async<U, F, Fut>(self, transform: F) -> DataStream<U>

where U: Send + 'static, F: FnMut(T) -> Fut + Send + 'static, Fut: Future<Output = U> + Send,

pub fn filter<F>(self, predicate: F) -> Self

where F: FnMut(&T) -> bool + Send + 'static,

pub fn batch(self, size: usize) -> DataStream<Vec<T>>

pub fn batch_with_timeout( self, size: usize, time_window: Duration, ) -> DataStream<Vec<T>>

Flush at size or a deadline measured from the first value in each batch. An idle source still flushes; a slow consumer applies channel backpressure.

pub fn window(self, size: usize) -> DataStream<Vec<T>>

where T: Clone,

pub fn sliding_window(self, size: usize) -> DataStream<Vec<T>>

where T: Clone,

Alias for a sliding window advancing by one value.

pub fn split<F>(self, predicate: F) -> (Self, Self)

where F: FnMut(&T) -> bool + Send + 'static,

pub fn merge(self, other: Self) -> Self

pub async fn collect(self) -> Vec<T>

pub async fn reduce<U, F>(self, initial: U, reducer: F) -> U

where F: FnMut(U, T) -> U,

pub async fn for_each<F, Fut>(self, callback: F)

where F: FnMut(T) -> Fut, Fut: Future<Output = ()>,

pub async fn analyze<E, R, U>( self, error: E, response: R, update: U, ) -> StreamStats

where E: FnMut(&T) -> bool, R: FnMut(&T) -> Option<f64>, U: FnMut(&StreamStats),

Trait Implementations

impl<T> Drop for DataStream<T>

fn drop(&mut self)

Executes the destructor for this type.

fn pin_drop(self: Pin<&mut Self>)

🔬This is a nightly-only experimental API. (pin_ergonomics)

Execute the destructor for this type, but different to Drop::drop, it requires self to be pinned.