Struct SingleSubscriberOutputStream 

pub struct SingleSubscriberOutputStream { /* private fields */ }

The output stream from a process. Either representing stdout or stderr.

This is the single-subscriber variant, allowing for just one consumer. This has the upside of requiring as few memory allocations as possible. If multiple concurrent inspections are required, prefer using the output_stream::broadcast::BroadcastOutputSteam.

Implementations

impl SingleSubscriberOutputStream

pub fn from_stream<S: AsyncRead + Unpin + Send + 'static>( stream: S, backpressure_control: BackpressureControl, options: FromStreamOptions, ) -> SingleSubscriberOutputStream

Creates a new single subscriber output stream from an async read stream.

impl SingleSubscriberOutputStream

pub fn inspect_chunks( &mut self, f: impl Fn(Chunk) -> Next + Send + 'static, ) -> Inspector

Inspects chunks of output from the stream without storing them.

The provided closure is called for each chunk of data. Return Next::Continue to keep processing or Next::Break to stop.

pub fn inspect_lines( &mut self, f: impl FnMut(String) -> Next + Send + 'static, options: LineParsingOptions, ) -> Inspector

Inspects lines of output from the stream without storing them.

The provided closure is called for each line. Return Next::Continue to keep processing or Next::Break to stop.

pub fn inspect_lines_async<Fut>( &mut self, f: impl FnMut(String) -> Fut + Send + 'static, options: LineParsingOptions, ) -> Inspector

where Fut: Future<Output = Next> + Send,

Inspects lines of output from the stream without storing them, using an async closure.

The provided async closure is called for each line. Return Next::Continue to keep processing or Next::Break to stop.

impl SingleSubscriberOutputStream

pub fn collect_chunks<S: Sink>( &mut self, into: S, collect: impl Fn(Chunk, &mut S) + Send + 'static, ) -> Collector<S>

Collects chunks from the stream into a sink.

The provided closure is called for each chunk, with mutable access to the sink.

pub fn collect_chunks_async<S, F>( &mut self, into: S, collect: F, ) -> Collector<S>

where S: Sink, F: Fn(Chunk, &mut S) -> Pin<Box<dyn Future<Output = Next> + Send + '_>> + Send + 'static,

Collects chunks from the stream into a sink using an async closure.

The provided async closure is called for each chunk, with mutable access to the sink.

pub fn collect_lines<S: Sink>( &mut self, into: S, collect: impl Fn(String, &mut S) -> Next + Send + 'static, options: LineParsingOptions, ) -> Collector<S>

Collects lines from the stream into a sink.

The provided closure is called for each line, with mutable access to the sink. Return Next::Continue to keep processing or Next::Break to stop.

pub fn collect_lines_async<S, F>( &mut self, into: S, collect: F, options: LineParsingOptions, ) -> Collector<S>

where S: Sink, F: Fn(String, &mut S) -> Pin<Box<dyn Future<Output = Next> + Send + '_>> + Send + Sync + 'static,

Collects lines from the stream into a sink using an async closure.

The provided async closure is called for each line, with mutable access to the sink. Return Next::Continue to keep processing or Next::Break to stop.

pub fn collect_chunks_into_vec(&mut self) -> Collector<Vec<u8>>

Convenience method to collect all chunks into a Vec<u8>.

pub fn collect_lines_into_vec( &mut self, options: LineParsingOptions, ) -> Collector<Vec<String>>

Convenience method to collect all lines into a Vec<String>.

pub fn collect_chunks_into_write<W: Sink + AsyncWriteExt + Unpin>( &mut self, write: W, ) -> Collector<W>

Collects chunks into an async writer.

pub fn collect_lines_into_write<W: Sink + AsyncWriteExt + Unpin>( &mut self, write: W, options: LineParsingOptions, ) -> Collector<W>

Collects lines into an async writer.

pub fn collect_chunks_into_write_mapped<W: Sink + AsyncWriteExt + Unpin, B: AsRef<[u8]> + Send>( &mut self, write: W, mapper: impl Fn(Chunk) -> B + Send + Sync + Copy + 'static, ) -> Collector<W>

Collects chunks into an async writer after mapping them with the provided function.

pub fn collect_lines_into_write_mapped<W: Sink + AsyncWriteExt + Unpin, B: AsRef<[u8]> + Send>( &mut self, write: W, mapper: impl Fn(String) -> B + Send + Sync + Copy + 'static, options: LineParsingOptions, ) -> Collector<W>

Collects lines into an async writer after mapping them with the provided function.

impl SingleSubscriberOutputStream

pub async fn wait_for_line( &mut self, predicate: impl Fn(String) -> bool + Send + Sync + 'static, options: LineParsingOptions, )

Waits for a line that matches the given predicate.

This method blocks until a line is found that satisfies the predicate.

pub async fn wait_for_line_with_timeout( &mut self, predicate: impl Fn(String) -> bool + Send + Sync + 'static, options: LineParsingOptions, timeout: Duration, ) -> Result<(), Elapsed>

Waits for a line that matches the given predicate, with a timeout.

Returns Ok(()) if a matching line is found, or Err(Elapsed) if the timeout expires.

Trait Implementations

impl Debug for SingleSubscriberOutputStream

fn fmt(&self, f: &mut Formatter<'_>) -> Result

Formats the value using the given formatter.

impl Drop for SingleSubscriberOutputStream

fn drop(&mut self)

Executes the destructor for this type.

impl OutputStream for SingleSubscriberOutputStream