Struct Plan 

pub struct Plan {

    pub identity: Identity,
    pub classification: Classification,
    pub findings: Vec<Finding>,
    pub style_candidates: Vec<StyleCandidate>,
    pub desired_state: DesiredState,
    pub observed_state: ObservedState,
    pub release: ReleaseSource,
    pub operations: Vec<Operation>,
    pub preconditions: Vec<Precondition>,
    pub decisions: Vec<Decision>,
    pub postconditions: Vec<Postcondition>,
    pub evidence: Vec<Evidence>,
    pub readiness: Readiness,
    pub input_fingerprint: Sha256,
}

The whole document.

Fields

identity: Identity

Which plan this is.

classification: Classification

What the target is.

findings: Vec<Finding>

What the corpus shows.

style_candidates: Vec<StyleCandidate>

Documents written before the instance, named and never judged.

desired_state: DesiredState

What the plan is aiming at.

observed_state: ObservedState

What the plan found.

release: ReleaseSource

Where the release came from.

operations: Vec<Operation>

Every write the apply will make, in apply order.

preconditions: Vec<Precondition>

Everything that must hold first.

decisions: Vec<Decision>

Everything the operator decides.

postconditions: Vec<Postcondition>

Everything the apply proves at the end.

evidence: Vec<Evidence>

What was observed, and how.

readiness: Readiness

Whether the plan may be applied.

input_fingerprint: Sha256

The digest over the semantic inputs an approval binds to.

Implementations

impl Plan

pub const fn is_ready(&self) -> bool

Whether an apply may proceed.

pub fn findings_of(&self, kind: FindingKind) -> Vec<&Finding>

Every finding of one kind.

pub fn structural_count(&self) -> usize

How many structural findings the corpus shows.

Trait Implementations

impl Clone for Plan

fn clone(&self) -> Plan

Returns a duplicate of the value.

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

Performs copy-assignment from source.

impl Debug for Plan

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

Formats the value using the given formatter.

impl<'de> Deserialize<'de> for Plan

fn deserialize<__D>(__deserializer: __D) -> Result<Self, __D::Error>

where __D: Deserializer<'de>,

Deserialize this value from the given Serde deserializer.

impl Eq for Plan

impl PartialEq for Plan

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

Equality operator ==.

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

Inequality operator !=.

impl Serialize for Plan

fn serialize<__S>(&self, __serializer: __S) -> Result<__S::Ok, __S::Error>

where __S: Serializer,

Serialize this value into the given Serde serializer.

impl StructuralPartialEq for Plan