Struct 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.