Struct Inputs 

pub struct Inputs<'a> {

    pub observation: &'a Observation,
    pub declaration: &'a Declaration,
    pub candidate: &'a BTreeMap<String, Sha256>,
    pub baseline: Option<&'a BTreeMap<String, Sha256>>,
    pub selector: String,
    pub release: String,
    pub release_sha256: Sha256,
    pub provenance: String,
    pub registry_checksum: Option<Sha256>,
    pub yanked: bool,
    pub compatibility: Option<&'a Compatibility>,
    pub interval: Option<&'a Interval>,
    pub briefing: Option<&'a Briefing>,
    pub proposed: Option<&'a [Operation]>,
    pub selections: &'a Selections,
    pub reserve: &'a [String],
    pub budget: &'a [Measurement],
    pub declared: Option<&'a str>,
    pub declarations_settled: bool,
    pub now: String,
}

What the planner is given besides the observation.

Fields

observation: &'a Observation

What was observed at the target.

declaration: &'a Declaration

What the destination release declares it lands.

candidate: &'a BTreeMap<String, Sha256>

Each destination’s bytes in the destination release, by source path.

baseline: Option<&'a BTreeMap<String, Sha256>>

Each destination’s bytes in the recorded release, where it could be read. Absent means the baseline was not observed.

selector: String

What the caller asked for, before resolution.

release: String

The release the selector resolved to.

release_sha256: Sha256

The digest over that release’s content.

provenance: String

Where the release’s facts came from.

registry_checksum: Option<Sha256>

The registry checksum, where a registry served it.

yanked: bool

Whether the registry marks the release yanked.

compatibility: Option<&'a Compatibility>

What the destination release needs of this engine.

interval: Option<&'a Interval>

The interval the plan crosses, for the compatibility check.

briefing: Option<&'a Briefing>

What the interval’s releases ask of this target.

proposed: Option<&'a [Operation]>

What one landing would write, where the caller computed it.

The installer owns that computation, so the planner takes its answer rather than deriving a second one that could disagree.

selections: &'a Selections

What the operator selected.

reserve: &'a [String]

Paths no delivered gate judges, as the caller reserved them.

budget: &'a [Measurement]

What the budget gates measured at the target.

The gates decide pass or fail; the planner reports a number over a cap as debt a corpus arrived with. One measurement, so a finding and a ceiling can never disagree about what a budget is.

declared: Option<&'a str>

The declarations a front carries, rendered for the fingerprint.

A front’s flags reach the record and no other operation, so a plan that recorded a different docs scratch would otherwise share an id with one that did not.

declarations_settled: bool

Whether the caller already settled the two declarations.

A front carries them as flags, and an omitted flag keeps whatever is recorded. So the questions are answered before the plan is computed, and asking them again would ask an operator to repeat something they already said.

now: String

The clock, as an input.

Trait Implementations

impl<'a> Clone for Inputs<'a>

fn clone(&self) -> Inputs<'a>

Returns a duplicate of the value.

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

Performs copy-assignment from source.

impl<'a> Debug for Inputs<'a>

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

Formats the value using the given formatter.