Struct Stream 

pub struct Stream { /* private fields */ }

A handle on a process’ Output or Error streams. The Handle can either be used asynchronously to read content as it is filled by the child, or synchronously by calling read_all, which will wait until the child terminates, then collect all output. For async, you can use read_line, or read for an exact byte count.

Content pulled with async functions are removed from the handle–it will not be present in read_all. Therefore, you likely want to either use this handle in one of the two modes.

Examples

Synchronous.

use std::os::fd::{OwnedFd, FromRawFd};
let mut handle = spawn::Stream::new(unsafe {OwnedFd::from_raw_fd(1)});
handle.read_all().unwrap();

Asynchronous.

use std::os::fd::{OwnedFd, FromRawFd};
let mut handle = spawn::Stream::new(unsafe {OwnedFd::from_raw_fd(1)});
while let Some(line) = handle.read_line() {
    println!("{line}");
}

Implementations

impl Stream

pub fn new(owned_fd: OwnedFd) -> Self

Construct a new StreamHandle from an OwnedFd connected to the child.

pub fn read_line(&self) -> Option<String>

Read a line from the stream. This function is blocking, and will wait until a full line has been written to the stream. The line will then be removed from the Handle.

pub fn read_bytes(&self, bytes: Option<usize>) -> Result<Vec<u8>, Error>

Read the exact amount of bytes specified, or else throw an error. This function is blocking.

pub fn read_blocking(&mut self) -> Result<String, Error>

Read everything currently in the pipe, blocking.

pub fn read_all(&mut self) -> Result<String, Error>

Read everything currently in the pipe. Not blocking.

pub fn wait(&mut self) -> Result<(), Error>

Join the worker thread, waiting until the subprocess closes their side of the pipe.

Trait Implementations

impl Drop for Stream

fn drop(&mut self)

Executes the destructor for this type.