Enum StoredReferenceExclusion 

#[non_exhaustive]
pub enum StoredReferenceExclusion {
    MissingStatus,
    Outdated,
    NotSimulated,
    External,
    Loaded,
    CannotRun,
    Aborted,
    UnknownStatus,
    MissingSimulator,
    UnsupportedSimulator,
    MissingCalculator,
    UnsupportedCalculator,
    MissingResults,
    MissingSummary,
    ImpossibleSummary,
    InconsistentResults,
    ParserWarning,
    FatalEvent,
    UninspectableSeries,
    ReducedDesign,
    MissingConfiguration,
    UnknownConfiguration,
    UnflyableConfiguration,
}

Why a stored simulation cannot be used as a validation reference.

Reading a result and accepting it as a reference are separate operations. This enum covers status, summary and internal-consistency checks that can be made from the stored simulation alone. A caller that has the containing design must additionally reject reduced designs and unknown motor configurations.

Variants (Non-exhaustive)

Non-exhaustive enums could have additional variants added in future. Therefore, when matching against variants of non-exhaustive enums, an extra wildcard arm must be added to account for any future variants.

MissingStatus

The simulation has no status, so it cannot be established as current.

Outdated

The simulation was recorded before the design changed.

NotSimulated

The file says that the simulation was not run.

External

The result came from an external simulator, not OpenRocket’s own run.

Loaded

The result was loaded rather than produced by a current run.

CannotRun

The simulation could not be run.

Aborted

The simulation was aborted.

UnknownStatus

The file contains a status not recognized by this reader.

MissingSimulator

The simulation has no <simulator>, so its producer cannot be established.

UnsupportedSimulator

The simulation names a producer other than the pinned OpenRocket RK4 simulator.

MissingCalculator

The simulation has no <calculator>, so its aerodynamic model cannot be established.

UnsupportedCalculator

The simulation names a calculator other than the pinned OpenRocket Barrowman calculator.

MissingResults

The simulation has no <flightdata>.

MissingSummary

The flightdata lacks one of the required ascent summary values.

ImpossibleSummary

A summary value is non-finite, negative, or otherwise impossible as a maximum.

InconsistentResults

The summary and stored time series contradict one another.

ParserWarning

The parser had to drop or reinterpret data belonging to this simulation.

FatalEvent

The stored flight ended with a fatal simulation event.

UninspectableSeries

A stored time series has rows but no recognized time or altitude column.

ReducedDesign

The containing design is reduced, so hpr cannot reproduce its full geometry.

MissingConfiguration

The stored run does not name a motor configuration.

UnknownConfiguration

The stored run names a configuration absent from the design.

UnflyableConfiguration

The named configuration cannot be flown by hpr as read.

Implementations

impl StoredReferenceExclusion

pub const fn reason(self) -> &'static str

The stable reason used by survey reports.

Trait Implementations

impl Clone for StoredReferenceExclusion

fn clone(&self) -> StoredReferenceExclusion

Returns a duplicate of the value.

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

Performs copy-assignment from source.

impl Copy for StoredReferenceExclusion

impl Debug for StoredReferenceExclusion

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

Formats the value using the given formatter.

impl<'de> Deserialize<'de> for StoredReferenceExclusion

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

where __D: Deserializer<'de>,

Deserialize this value from the given Serde deserializer.

impl Eq for StoredReferenceExclusion

impl Hash for StoredReferenceExclusion

fn hash<__H: Hasher>(&self, state: &mut __H)

Feeds this value into the given Hasher.

fn hash_slice<H>(data: &[Self], state: &mut H)

where H: Hasher, Self: Sized,

Feeds a slice of this type into the given Hasher.

impl PartialEq for StoredReferenceExclusion

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

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 StoredReferenceExclusion