Struct Patience 

pub struct Patience {
    pub cold: Duration,
    pub moved: Duration,
}

How long a read waits for a worker before it returns what it has.

use majordomus_cli::capability::readings::Patience;
use std::time::Duration;

// a page waits a minute for a first reading and 50 ms for a moved repository
assert_eq!(Patience::PAGE.cold, Duration::from_secs(60));
assert_eq!(Patience::PAGE.moved, Duration::from_millis(50));
// an exact read waits for as long as it takes
assert_eq!(Patience::WAIT.moved, Duration::MAX);
let brief = Patience { cold: Duration::from_millis(5), moved: Duration::ZERO };
assert!(brief.moved < Patience::PAGE.moved);

Fields

cold: Duration

For a source that has never been read in this process.

moved: Duration

For a source read before the repository last moved.

Implementations

impl Patience

pub const WAIT: Patience

Wait for a current reading, however long it takes.

pub const PAGE: Patience

What a page is served with: a first reading is waited for up to a minute, because there is nothing else to show, and a reading the repository has moved past for 50 ms, half of the 100 ms a warm page is allowed (the owner’s UI-performance pack).

pub fn of_process() -> Patience

The patience of this process: PATIENCE_SWITCH when it is set, and otherwise Patience::PAGE. The crate’s own unit tests wait, so that a test which renders a screen asserts on a current reading and never on a timing.

use majordomus_cli::capability::readings::{Patience, PATIENCE_SWITCH};

// what the switch says when it is set and means something, a page's patience otherwise
let set = std::env::var(PATIENCE_SWITCH).ok();
let expected = Patience::parse(set.as_deref()).unwrap_or(Patience::PAGE);
assert_eq!(Patience::of_process(), expected);

pub fn parse(value: Option<&str>) -> Option<Patience>

What a value of PATIENCE_SWITCH means, or None when it means nothing: wait is Patience::WAIT, and a number is that many milliseconds for a repository that has moved, with a first reading waited for no less than a page waits.

use majordomus_cli::capability::readings::Patience;
assert_eq!(Patience::parse(Some("wait")), Some(Patience::WAIT));
let twenty = Patience::parse(Some(" 20 ")).unwrap();
assert_eq!(twenty.moved.as_millis(), 20);
assert_eq!(twenty.cold, Patience::PAGE.cold, "a first reading is still waited for");
assert_eq!(Patience::parse(Some("soon")), None, "not a number and not `wait`");
assert_eq!(Patience::parse(None), None);

Trait Implementations

impl Clone for Patience

fn clone(&self) -> Patience

Returns a duplicate of the value.

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

Performs copy-assignment from source.

impl Copy for Patience

impl Debug for Patience

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

Formats the value using the given formatter.

impl Eq for Patience

impl PartialEq for Patience

fn eq(&self, other: &Patience) -> 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.

impl StructuralPartialEq for Patience