Struct WriteChunks 

pub struct WriteChunks<W, H, F, B>
where
    W: Sink + AsyncWriteExt + Unpin,
    H: SinkWriteErrorHandler,
    B: AsRef<[u8]> + Send + 'static,
    F: Fn(Chunk) -> B + Send + Sync + 'static,
{
    pub stream_name: &'static str,
    pub writer: W,
    pub error_handler: H,
    pub mapper: F,
    pub error: Option<SinkWriteError>,
}

Asynchronous StreamVisitor that runs each observed chunk through mapper, writes the resulting bytes via writer, and routes failures through error_handler. The visitor surfaces the writer (or the first sink write error) via AsyncStreamVisitor::into_output.

The two common shapes have dedicated constructors:

• WriteChunks::passthrough writes each chunk’s raw bytes unchanged.
• WriteChunks::mapped runs each chunk through a user mapper first.

If you need full control over every field (e.g. injecting a pre-existing SinkWriteError into the error slot for tests), use builder directly.

WriteChunks is AsyncStreamVisitor-only because the underlying writer is AsyncWriteExt. There is no synchronous counterpart; reach for CollectChunks (with a sink that performs the blocking write) if you need a sync chunk-level visitor.

Fields

stream_name: &'static str

Stream name used to label any SinkWriteError this visitor surfaces.

writer: W

Async writer chunks are forwarded into.

error_handler: H

Routing for sink write failures.

mapper: F

Per-chunk mapper that produces the bytes actually written to writer.

error: Option<SinkWriteError>

Latest sink write error, if any. Constructors initialize this to None. The visitor writes into it before signaling Next::Break.

Implementations

impl<W, H, F, B> WriteChunks<W, H, F, B>

where W: Sink + AsyncWriteExt + Unpin, H: SinkWriteErrorHandler, B: AsRef<[u8]> + Send + 'static, F: Fn(Chunk) -> B + Send + Sync + 'static,

pub fn builder() -> WriteChunksBuilder<W, H, F, B, ((), (), (), (), ())>

Create a builder for building WriteChunks. On the builder, call .stream_name(...), .writer(...), .error_handler(...), .mapper(...), .error(...)(optional) to set the values of the fields. Finally, call .build() to create the instance of WriteChunks.

impl<W, H> WriteChunks<W, H, fn(Chunk) -> Chunk, Chunk>

where W: Sink + AsyncWriteExt + Unpin, H: SinkWriteErrorHandler,

pub fn passthrough( stream_name: &'static str, writer: W, options: WriteCollectionOptions<H>, ) -> Self

Identity-mapper constructor. Each chunk’s raw bytes are written to writer unchanged. stream_name labels any SinkWriteError this visitor surfaces.

impl<W, H, F, B> WriteChunks<W, H, F, B>

where W: Sink + AsyncWriteExt + Unpin, H: SinkWriteErrorHandler, B: AsRef<[u8]> + Send + 'static, F: Fn(Chunk) -> B + Send + Sync + 'static,

pub fn mapped( stream_name: &'static str, writer: W, options: WriteCollectionOptions<H>, mapper: F, ) -> Self

Mapped constructor. Each chunk is run through mapper before being written. Use this when the bytes you want to forward differ from the raw chunk bytes (for example, a rendered line, an envelope-wrapped frame, or a transcoded representation).

Trait Implementations

impl<W, H, F, B> AsyncStreamVisitor for WriteChunks<W, H, F, B>

where W: Sink + AsyncWriteExt + Unpin, H: SinkWriteErrorHandler, B: AsRef<[u8]> + Send + 'static, F: Fn(Chunk) -> B + Send + Sync + 'static,

type Output = Result<W, SinkWriteError>

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

async fn on_chunk(&mut self, chunk: Chunk) -> Next

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.