Struct AdoptionPlan 

pub struct AdoptionPlan { /* private fields */ }

An organization’s proposed Rakkotan adoption.

Implementations

impl AdoptionPlan

pub fn new(organization: impl Into<String>) -> Result<Self, AdoptionError>

Creates an unassessed plan for a non-blank organization name.

Examples found in repository

examples/review_adoption.rs (line 4)

fn main() -> Result<(), Box<dyn std::error::Error>> {
    let plan = AdoptionPlan::new("Example Corp")?
        .assess(
            P::PurposeAndOutcome,
            Finding::Satisfied,
            "pilot goal is measurable",
        )?
        .assess(
            P::AuthorityAndTerms,
            Finding::Satisfied,
            "approver and terms recorded",
        )?
        .assess(
            P::DataGovernance,
            Finding::Satisfied,
            "data flow and retention recorded",
        )?
        .assess(
            P::UserProtection,
            Finding::Satisfied,
            "support and access needs reviewed",
        )?
        .assess(
            P::OperationalOwnership,
            Finding::NeedsRevision,
            "backup owner is not assigned",
        )?
        .assess(
            P::ReversibleAdoption,
            Finding::Satisfied,
            "exit process documented",
        )?;

    let report = AdoptionPolicy::evaluate(&plan);
    println!("organization: {}", plan.organization());
    println!("decision: {:?}", report.decision());
    println!("unresolved: {:?}", report.unresolved());
    Ok(())
}

pub fn assess( self, principle: AdoptionPrinciple, finding: Finding, evidence: impl Into<String>, ) -> Result<Self, AdoptionError>

Adds or replaces an assessment and returns the plan for chaining.

Examples found in repository

examples/review_adoption.rs (lines 5-9)

fn main() -> Result<(), Box<dyn std::error::Error>> {
    let plan = AdoptionPlan::new("Example Corp")?
        .assess(
            P::PurposeAndOutcome,
            Finding::Satisfied,
            "pilot goal is measurable",
        )?
        .assess(
            P::AuthorityAndTerms,
            Finding::Satisfied,
            "approver and terms recorded",
        )?
        .assess(
            P::DataGovernance,
            Finding::Satisfied,
            "data flow and retention recorded",
        )?
        .assess(
            P::UserProtection,
            Finding::Satisfied,
            "support and access needs reviewed",
        )?
        .assess(
            P::OperationalOwnership,
            Finding::NeedsRevision,
            "backup owner is not assigned",
        )?
        .assess(
            P::ReversibleAdoption,
            Finding::Satisfied,
            "exit process documented",
        )?;

    let report = AdoptionPolicy::evaluate(&plan);
    println!("organization: {}", plan.organization());
    println!("decision: {:?}", report.decision());
    println!("unresolved: {:?}", report.unresolved());
    Ok(())
}

pub fn set_assessment( &mut self, principle: AdoptionPrinciple, finding: Finding, evidence: impl Into<String>, ) -> Result<(), AdoptionError>

Adds or replaces one assessment in place.

pub fn organization(&self) -> &str

Returns the organization name.

Examples found in repository

examples/review_adoption.rs (line 37)

fn main() -> Result<(), Box<dyn std::error::Error>> {
    let plan = AdoptionPlan::new("Example Corp")?
        .assess(
            P::PurposeAndOutcome,
            Finding::Satisfied,
            "pilot goal is measurable",
        )?
        .assess(
            P::AuthorityAndTerms,
            Finding::Satisfied,
            "approver and terms recorded",
        )?
        .assess(
            P::DataGovernance,
            Finding::Satisfied,
            "data flow and retention recorded",
        )?
        .assess(
            P::UserProtection,
            Finding::Satisfied,
            "support and access needs reviewed",
        )?
        .assess(
            P::OperationalOwnership,
            Finding::NeedsRevision,
            "backup owner is not assigned",
        )?
        .assess(
            P::ReversibleAdoption,
            Finding::Satisfied,
            "exit process documented",
        )?;

    let report = AdoptionPolicy::evaluate(&plan);
    println!("organization: {}", plan.organization());
    println!("decision: {:?}", report.decision());
    println!("unresolved: {:?}", report.unresolved());
    Ok(())
}

pub fn assessment(&self, principle: AdoptionPrinciple) -> Option<&Assessment>

Returns an assessment when recorded.

Trait Implementations

impl Clone for AdoptionPlan

fn clone(&self) -> AdoptionPlan

Returns a duplicate of the value.

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

Performs copy-assignment from source.

impl Debug for AdoptionPlan

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

Formats the value using the given formatter.

impl Eq for AdoptionPlan

impl PartialEq for AdoptionPlan

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

Equality operator ==.

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

Inequality operator !=.

impl StructuralPartialEq for AdoptionPlan