Struct WriteLines 

pub struct WriteLines<W, H, F, B>
where
    W: Sink + AsyncWriteExt + Unpin,
    H: SinkWriteErrorHandler,
    B: AsRef<[u8]> + Send + 'static,
    F: Fn(Cow<'_, str>) -> B + Send + Sync + 'static,
{ /* private fields */ }

AsyncLineVisitor that maps each parsed line through mapper, writes the result via writer, and routes failures through error_handler. Compose with ParseLines (its AsyncStreamVisitor impl is selected automatically when the inner sink is an AsyncLineVisitor) and pass the resulting visitor to Consumable::consume_async.

The common identity-mapper shape has a dedicated constructor: WriteLines::passthrough. For mappers that change the line bytes, use WriteLines::new with a typed mapper closure.

Implementations

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

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

pub fn new( stream_name: &'static str, writer: W, error_handler: H, mapper: F, mode: LineWriteMode, ) -> Self

Creates a new sink that maps each parsed line through mapper, writes the result to writer with the requested mode, and routes failures through error_handler. stream_name labels the stream in any SinkWriteError this sink emits.

impl<W, H> WriteLines<W, H, fn(Cow<'_, str>) -> String, String>

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

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

Identity-mapper constructor. Each parsed line is written to writer (with mode) without transformation. stream_name labels any SinkWriteError this sink emits.

Trait Implementations

impl<W, H, F, B> AsyncLineVisitor for WriteLines<W, H, F, B>

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

type Output = Result<W, SinkWriteError>

Final value produced once the adapter is finished.

async fn on_line<'a>(&'a mut self, line: Cow<'a, str>) -> Next

Asynchronously observes a single parsed line. Return Next::Break to stop further parsing.

fn into_output(self) -> Self::Output

Consumes the sink and returns its final output.

fn on_gap(&mut self)

Synchronous gap hook; default no-op. See LineVisitor::on_gap.

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

Asynchronous EOF hook; default no-op. Invoked after the adapter has flushed any trailing line through on_line.