Struct Outcome 

pub struct Outcome {
    pub id: String,
    pub advisor: String,
    pub status: ConsultationStatus,
    pub at: i64,
    pub retry_after: Option<u64>,
}

The recorded outcome of one consultation, as availability reads it: the advisor, how the consultation ended and when. The circuit is computed from these alone.

use majordomus_cli::reasoning::availability::*;
use majordomus_cli::reasoning::catalogue::{AdvisorCatalogue, References};
use majordomus_cli::reasoning::record::ConsultationStatus;

struct All;
impl Presence for All {
    fn executable(&self, _: &str) -> bool { true }
    fn variable(&self, _: &str) -> bool { true }
}
let c: AdvisorCatalogue = majordomus_cli::metadata::yaml::parse_into(
    "version: 1\ncapabilities:\n  - id: code_review\n    description: x\nadvisors:\n  - id: a\n    title: A\n    transport: cli\n    adapter: a-cli\n    executable: a\n    capabilities: [code_review]\n",
).unwrap();
// a refused credential keeps the advisor out for AUTH_COOLDOWN seconds
let refused = [Outcome {
    id: "consultation-1".into(), advisor: "a".into(),
    status: ConsultationStatus::AuthFailed, at: 0, retry_after: None,
}];
let refs = References::default();
let at = |now| derive_availability(&c, &Inputs {
    refs: &refs, presence: &All, mode: ReasoningMode::Standard, disabled: &[],
    history: &refused, peers: &[], now, cooldown: None,
})[0].reason.clone();
assert_eq!(at(1), "authentication_failed");
assert_eq!(at(AUTH_COOLDOWN), "present");

Fields

id: String

The consultation record id; the tie-break of equal stamps.

advisor: String

The advisor asked.

status: ConsultationStatus

How it ended.

at: i64

When it was recorded, seconds since the epoch.

retry_after: Option<u64>

A rate limit’s own retry-after, seconds.

Trait Implementations

impl Clone for Outcome

fn clone(&self) -> Outcome

Returns a duplicate of the value.

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

Performs copy-assignment from source.

impl Debug for Outcome

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

Formats the value using the given formatter.

impl Eq for Outcome

impl PartialEq for Outcome

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