Struct CollectChunksAsync 

pub struct CollectChunksAsync<T, F>
where
    T: Sink,
    F: for<'a> FnMut(Chunk, &'a mut T) -> Pin<Box<dyn Future<Output = Next> + Send + 'a>> + Send + 'static,
{ /* private fields */ }

Asynchronous counterpart to CollectChunks. The per-chunk hook is a closure that returns a boxed future, allowing the future to borrow chunk and sink across .await while remaining Send for tokio::spawn. Construct via fold and pass to Consumable::consume_async.

The boxed future incurs one allocation per observed chunk; for hot paths that cannot afford that, implement AsyncStreamVisitor directly on a struct that owns the sink.

Example

let visitor = CollectChunksAsync::fold(Vec::<u8>::new(), |chunk, sink| {
    Box::pin(async move {
        sink.extend_from_slice(chunk.as_ref());
        Next::Continue
    })
});

Implementations

impl<T, F> CollectChunksAsync<T, F>

where T: Sink, F: for<'a> FnMut(Chunk, &'a mut T) -> Pin<Box<dyn Future<Output = Next> + Send + 'a>> + Send + 'static,

pub fn fold(sink: T, f: F) -> Self

Fold-style constructor: sink is the initial accumulator and f folds each observed chunk into it asynchronously. The closure must wrap its async body in Box::pin(async move { ... }) so the returned future can borrow chunk and sink while remaining Send.

Trait Implementations

impl<T, F> AsyncStreamVisitor for CollectChunksAsync<T, F>

where T: Sink, F: for<'a> FnMut(Chunk, &'a mut T) -> Pin<Box<dyn Future<Output = Next> + Send + 'a>> + Send + 'static,

type Output = T

The value produced by into_output after the visitor has finished observing the stream. Returned via Consumer::wait and Consumer::cancel.

fn on_chunk(&mut self, chunk: Chunk) -> impl Future<Output = Next> + Send + '_

Asynchronously observes a single chunk.

fn into_output(self) -> Self::Output

Consumes the visitor and returns its final output.

fn on_gap(&mut self)

Invoked when the stream backend reports that one or more chunks were dropped between the last delivered chunk and the next one.

fn on_eof(&mut self) -> impl Future<Output = ()> + Send + '_

Asynchronously observes end-of-stream.