Enum Trouble 

pub enum Trouble {
    NotInstalled,
    DaemonStopped,
    MachineStopped,
    Refused(String),
    NotRunnable(String),
}

Why the engine cannot be used, in a shape a screen can keep.

Unavailable carries a std::io::Error, so it can be neither cloned nor compared, while a screen’s state and every message travelling through it have to be both. This keeps the distinctions the person is told apart by and turns the rest into the words they read.

Variants

NotInstalled

No binary anywhere QCode looked.

DaemonStopped

Docker is installed and its daemon is not answering.

MachineStopped

Podman is installed and the Linux virtual machine it needs is not running.

Refused(String)

The engine ran and refused, carrying what it said.

NotRunnable(String)

A binary was found and could not be started, carrying what the system said.

Implementations

impl Trouble

pub fn of(unavailable: &Unavailable) -> Self

What the engine layer found, kept for a screen.

pub fn brief(&self, kind: EngineKind) -> String

The few words the repair strip has room for. The strip stands over every screen, so it stays one row in a narrow terminal; the whole sentence is headline, on the settings screen, where there is room to read it.

pub fn headline(&self, kind: EngineKind) -> String

The one sentence that says what is wrong.

pub fn remedy(&self, kind: EngineKind) -> String

What the person has to do about it. Repair is named in each one, because repair is the only thing the strip offers and a sentence that stops without a next step reads as a dead end.

pub fn said(&self) -> Option<&str>

What the engine or the system said, for the person to read, when there were words.

Trait Implementations

impl Clone for Trouble

fn clone(&self) -> Self

Returns a duplicate of the value.

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

Performs copy-assignment from source.

impl Debug for Trouble

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

Formats the value using the given formatter.

impl Eq for Trouble

impl PartialEq for Trouble

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

Equality operator ==.

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

Inequality operator !=.

impl StructuralPartialEq for Trouble