Struct par_stream::builder::ParAsyncBuilder

pub struct ParAsyncBuilder<St, Fac> where
    St: ?Sized + Stream,
    St::Item: 'static + Send,
    Fac: FutureFactory<St::Item>,
    Fac::Fut: 'static + Send + Future,
    <Fac::Fut as Future>::Output: Send,  { /* private fields */ }

The parallel stream builder with scheduled asynchronous tasks.

Implementations

impl<St, Fac> ParAsyncBuilder<St, Fac> where
    St: Stream,
    St::Item: 'static + Send,
    Fac: 'static + Send + FutureFactory<St::Item>,
    Fac::Fut: 'static + Send + Future,
    <Fac::Fut as Future>::Output: 'static + Send, 

pub fn map_async<NewFac, NewFut>(
    self,
    new_fac: NewFac
) -> ParAsyncBuilder<St, ComposeFutureFactory<St::Item, Fac, NewFac>> where
    NewFac: 'static + Send + Clone + FnMut(<Fac::Fut as Future>::Output) -> NewFut,
    NewFut: 'static + Send + Future,
    NewFut::Output: 'static + Send, 

Schedule an asynchronous task.

pub fn map_blocking<NewOut, NewFac, NewFunc>(
    self,
    new_fac: NewFac
) -> ParAsyncTailBlockBuilder<St, Fac, NewFac, NewOut> where
    NewFac: 'static + Send + Clone + FnMut(<Fac::Fut as Future>::Output) -> NewFunc,
    NewFunc: 'static + Send + FnOnce() -> NewOut,
    NewFunc::Output: 'static + Send, 

Schedules a blocking task.

The worker thread will pass the blocking task to a blocking thread and wait for the task to finish. It will introduce overhead on spawning blocking threads.

pub fn build_unordered_stream<P>(
    self,
    params: P
) -> UnorderedStream<<Fac::Fut as Future>::Output> where
    St: 'static + Send,
    P: Into<ParParams>, 

Creates a stream that runs scheduled parallel tasks, which output does not respect the input order.

pub fn build_ordered_stream<P>(
    self,
    params: P
) -> OrderedStream<<Fac::Fut as Future>::Output> where
    St: 'static + Send,
    P: Into<ParParams>, 

Creates a stream that runs scheduled parallel tasks, which output respects the input order.

impl<St, Fac> ParAsyncBuilder<St, Fac> where
    St: 'static + Send + Stream,
    St::Item: 'static + Send,
    Fac: 'static + Send + FutureFactory<St::Item>,
    Fac::Fut: 'static + Send + Future<Output = ()>, 

pub async fn for_each<P>(self, params: P) where
    P: Into<ParParams>, 

Runs parallel tasks on each stream item.

impl<St, Fac, Error> ParAsyncBuilder<St, Fac> where
    St: 'static + Send + Stream,
    St::Item: 'static + Send,
    Fac: 'static + Send + FutureFactory<St::Item>,
    Fac::Fut: 'static + Send + Future<Output = Result<(), Error>>,
    Error: 'static + Send, 

pub async fn try_for_each<P>(self, params: P) -> Result<(), Error> where
    P: Into<ParParams>, 

Runs parallel tasks on each stream item.