Struct factorio_bot_core::process::InteractiveProcess

pub struct InteractiveProcess { /* private fields */ }

Wraps a Child object in an interface for doing newline-dellimited string IO with a child process.

Calling send sends a string to the process’s stdin. A newline delimiter is automatically appended. If newline characters are present in the provided string, they will not be escaped.

Each newline-separated string sent by the child process over stdout results a call to the provided line_callback function. The line is wrapped in a std::io::Result; it will be in the Err state if the line is not valid UTF-8.

A callback may optionally be provided (via new_with_exit_callback) which is invoked when the child’s stdout stream is closed.

Implementations

impl InteractiveProcess

pub fn new<T>(command: Command, line_callback: T) -> Result<Self> where
    T: FnMut(Result<String>) + Send + 'static, 

Attempt to start a process for the provided Command, capturing the standard in and out streams for later use. The provided callback is called for every newline-terminated string written to stdout by the process.

pub fn new_with_stderr<T, E>(
    command: Command,
    stdout_callback: T,
    stderr_callback: E
) -> Result<Self> where
    T: FnMut(Result<String>) + Send + 'static,
    E: FnMut(Result<String>) + Send + 'static, 

Attempt to start a process for the provided Command, capturing the standard in and out/err streams for later use. The provided stdout callback is called for every newline-terminated string written to stdout by the process. The provided stderr callback is called for every newline-terminated string written to stderr by the process.

pub fn new_with_exit_callback<T, E, S>(
    command: Command,
    stdout_callback: T,
    stderr_callback: Option<E>,
    exit_callback: S
) -> Result<Self> where
    T: FnMut(Result<String>) + Send + 'static,
    E: FnMut(Result<String>) + Send + 'static,
    S: Fn() + Send + 'static, 

Constructor with the same semantics as new, except that an additional no-argument closure is provided which is called when the client exits.

pub fn send(&mut self, data: &str) -> Result<()>

Send a string to the client process’s stdin stream. A newline will be appended to the string.

pub fn send_unterminated(&mut self, data: &str) -> Result<()>

Send a string to the client process’s stdin stream, without appending a newline.

pub fn close(self) -> Child

Consume this InteractiveProcess and return its child. This closes the process’s stdin stream, which usually kills the process. If it doesn’t, you can use the returned Child object to kill it:

proc = InteractiveProces::new(…); proc.take().kill().unwrap();

pub fn wait(self) -> Result<ExitStatus>

Block the current thread on the process exiting, and return the exit code when it does. This does not send a signal to kill the child, so it only makes sense when the child process is self-terminating.