Struct ProcessResult 

pub struct ProcessResult<T> { /* private fields */ }

The captured result of running a process to completion.

T is the standard-output payload: String for the text helpers (output_string) or Vec<u8> for the raw-bytes helper (output_bytes). Standard error is always captured as text. A non-zero exit code is not treated as an error on its own — inspect code or call ensure_success.

#[must_use]: the result is the exit status — dropping it unread discards the only signal that the command failed. Call is_success / code / ensure_success. If you only need the side effect, prefer a verb that never produces a result to discard — run_unit (error-or-()) or exit_code — rather than capturing and binding to let _.

Implementations

impl<T> ProcessResult<T>

pub fn program(&self) -> &str

The program this result is attributed to (lossy UTF-8 of the program name) — the same value the error variants carry. For a Pipeline outcome this is the pipefail-attributed stage: the first stage that didn’t exit cleanly, or the last stage when every stage succeeded.

pub fn stdout(&self) -> &T

The captured standard output (text or bytes depending on T).

pub fn into_stdout(self) -> T

Consume the result and return just the captured standard output.

pub fn stderr(&self) -> &str

The captured standard error.

pub fn outcome(&self) -> Outcome

How the run ended, as the explicit three-way Outcome.

pub fn code(&self) -> Option<i32>

The process exit code, or None when the run yielded no code — killed by its timeout (timed_out is then true) or terminated by a signal on Unix (timed_out is false). There is no synthetic sentinel: a missing code is None, never -1. Derived from outcome.

pub fn timed_out(&self) -> bool

Whether the run was killed because it exceeded its timeout. Derived from outcome.

pub fn signal(&self) -> Option<i32>

The signal number if the process was terminated by a signal with a known number (Unix only; None otherwise — a clean exit, a timeout, or a signal the kernel did not expose). Derived from outcome; the Outcome-level twin is Outcome::signal.

pub fn is_success(&self) -> bool

Whether the process exited with an accepted code — 0 by default, or any code in the set configured via Command::ok_codes.

pub fn ensure_success(self) -> Result<ProcessResult<T>, Error>

where T: StdoutText,

Return self unchanged when the run succeeded, otherwise the matching error: Error::Timeout if the run was killed by its deadline (checked first), Error::Signalled if it was terminated by a signal (no exit code), else Error::Exit for an exit code outside the accepted set (code 0 by default — see Command::ok_codes), carrying the code and both captured streams in full (the Display impl bounds what it prints; the fields stay complete for classification).

pub fn duration(&self) -> Duration

The wall-clock duration of the run — spawn to exit (or kill). It is Duration::ZERO for synthetic results that didn’t time a real process (a scripted/replayed bulk output_string).

pub fn truncated(&self) -> bool

Whether a bounded OutputBufferPolicy discarded captured output lines (one or more lines were dropped by the buffer policy). Lines a streaming consumer popped are not truncation, so this stays false under the default unbounded policy even after a partial stdout_lines stream, and for the raw stdout of output_bytes (not line-buffered).

impl ProcessResult<String>

pub fn combined(&self) -> String

Standard output followed by standard error, joined — handy when a tool interleaves diagnostics across both streams.

A \n separator is inserted between the streams when stdout is non-empty and does not already end with a newline, preventing the last stdout line from being glued to the first stderr line.

pub fn diagnostic(&self) -> &str

The best human-facing message from a captured run, trimmed of surrounding whitespace: standard error if it carries text, otherwise standard output — git/jj put CONFLICT … and nothing to commit on stdout, so a probe that captured the result (rather than erroring) can build the same friendly message Error::diagnostic gives the erroring path. For the raw, untrimmed streams use stdout / stderr.

Trait Implementations

impl<T> Clone for ProcessResult<T>

where T: Clone,

fn clone(&self) -> ProcessResult<T>

Returns a duplicate of the value.

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

Performs copy-assignment from source.

impl<T> Debug for ProcessResult<T>

where T: Debug,

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

Formats the value using the given formatter.

impl<T> Eq for ProcessResult<T>

where T: Eq,

impl<T> PartialEq for ProcessResult<T>

where T: PartialEq,

fn eq(&self, other: &ProcessResult<T>) -> bool

Tests for self and other values to be equal, and is used by ==.

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

Tests for !=. The default implementation is almost always sufficient, and should not be overridden without very good reason.