Struct LiveChild 

pub struct LiveChild { /* private fields */ }

A program a DetachedHandoff left running: its standard input is the application’s to write, its later output arrives as messages through DetachedHandoff::on_line.

Clones share the one program, so the application can keep one in its state and move others into background work. When the last clone is dropped — at the latest when the application’s state is dropped as the run ends — the program’s standard input is closed and it reads the end of its input; ending it before that is the application’s decision (LiveChild::close_stdin, LiveChild::kill).

After its first line the program runs in the background of the terminal, which the application draws on again. Its standard error is still the terminal, so it should keep quiet there from then on: anything it writes lands on the application’s screen until the next full redraw.

Implementations

impl LiveChild

pub fn for_tests() -> (Self, TestChild)

A stand-in for tests, with the handle a test drives it through: what the application writes is recorded there, and the test says the program’s lines and ends it. Answer a detached handoff with it through Harness::set_detached_outcome.

use qframe::runtime::{ChildLine, LiveChild};

let (child, program) = LiveChild::for_tests();
child.write_line("status")?;
assert_eq!(program.written(), ["status"]);
assert_eq!(child.try_wait()?, None, "it runs until the test ends it");
program.exit(Some(0));
assert_eq!(child.try_wait()?, Some(Some(0)));

pub fn id(&self) -> Option<u32>

The program’s process id, or None for the stand-in of LiveChild::for_tests.

pub fn write_line(&self, line: &str) -> Result<()>

Writes line and a newline to the program’s standard input. A line holding newlines reaches the program as several lines.

The write blocks while the pipe is full, which only happens when the program stops reading; a program that answers each line keeps it empty.

Errors

Returns an error once the standard input is closed (io::ErrorKind::BrokenPipe) or the program no longer reads it.

pub fn close_stdin(&self)

Closes the program’s standard input, for every clone: the program reads the end of its input, which is how a helper that serves one line at a time is asked to finish. Closing it again does nothing.

pub fn kill(&self) -> Result<()>

Ends the program at once (SIGKILL on Unix); its ChildLine::Ended follows. Killing one that already ended does nothing.

Errors

Returns the system’s error, such as when the program runs as another user and may not be signalled, which is the case for one started through pkexec or sudo: close its standard input instead.

pub fn try_wait(&self) -> Result<Option<Option<i32>>>

How the program ended, without waiting: None while it runs, then Some(code), where code is None when a signal ended it, as in HandoffOutcome::Finished.

Errors

Returns the system’s error when the program’s state cannot be read.

Trait Implementations

impl Clone for LiveChild

fn clone(&self) -> LiveChild

Returns a duplicate of the value.

fn clone_from(&mut self, source: &Self)

Performs copy-assignment from source.

impl Debug for LiveChild

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

Formats the value using the given formatter.

impl Eq for LiveChild

impl PartialEq for LiveChild

Two handles are equal when they are clones of each other: the same program.

fn eq(&self, other: &Self) -> bool

Equality operator ==.

fn ne(&self, other: &Rhs) -> bool

Inequality operator !=.