Struct StoredSimulation 

#[non_exhaustive]
pub struct StoredSimulation {
    pub name: String,
    pub status: Option<String>,
    pub simulator: Option<String>,
    pub calculator: Option<String>,
    pub conditions: Option<LaunchConditions>,
    pub results: Option<StoredResults>,
    pub parser_warnings: bool,
}

A simulation stored in a .ork.

Fields (Non-exhaustive)

Non-exhaustive structs could have additional fields added in future. Therefore, non-exhaustive structs cannot be constructed in external crates using the traditional Struct { .. } syntax; cannot be matched against without a wildcard ..; and struct update syntax will not work.

name: String

<name>.

status: Option<String>

The status attribute as written: uptodate, outdated, loaded, external, notsimulated, cantrun or aborted in the files OpenRocket 24.12 writes.

simulator: Option<String>

<simulator>, such as RK4Simulator.

calculator: Option<String>

<calculator>, such as BarrowmanCalculator.

conditions: Option<LaunchConditions>

<conditions>: what the run was flown in.

results: Option<StoredResults>

<flightdata>: what it gave, when OpenRocket saved it.

parser_warnings: bool

Whether reading this simulation required dropping or reinterpreting stored data.

Implementations

impl StoredSimulation

pub fn reference_exclusion(&self) -> Option<StoredReferenceExclusion>

Returns why this stored result must not become a validation reference.

Only an explicitly uptodate simulation with the accepted OPENROCKET_SIMULATOR and OPENROCKET_CALCULATOR provenance markers and finite, positive ascent summary values is eligible. The two identifiers establish the recorded producer names, not a complete identity fingerprint for the OpenRocket version, settings or design. Optional summary values are checked when present. A time series is not required: OpenRocket can save a useful summary without one. When a time series includes time and altitude, its finite values must be non-negative apart from a 1 mm ground-contact rounding allowance, and time must not run backwards. The selected summary branch’s maximum altitude must agree with the stored apogee in both directions within max(0.1% of apogee, 1 mm). When multiple branches record an apogee, the first such branch in file order is selected; the reader does not infer branch identity from a matching maximum. A single altitude-bearing branch is selected even without an apogee event; multiple such branches without an apogee event are uninspectable because the summary branch cannot be identified. A branch with rows but no recognized time or altitude column is not inspectable. No arbitrary lower altitude threshold is used: a small but internally consistent flight is not impossible merely because it is small. Fatal events and event times outside the stored flight are also rejected.

Trait Implementations

impl Clone for StoredSimulation

fn clone(&self) -> StoredSimulation

Returns a duplicate of the value.

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

Performs copy-assignment from source.

impl Debug for StoredSimulation

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

Formats the value using the given formatter.

impl<'de> Deserialize<'de> for StoredSimulation

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

where __D: Deserializer<'de>,

Deserialize this value from the given Serde deserializer.

impl JsonSchema for StoredSimulation

fn schema_name() -> Cow<'static, str>

The name of the generated JSON Schema.

fn schema_id() -> Cow<'static, str>

Returns a string that uniquely identifies the schema produced by this type.

fn json_schema(generator: &mut SchemaGenerator) -> Schema

Generates a JSON Schema for this type.

fn inline_schema() -> bool

Whether JSON Schemas generated for this type should be included directly in parent schemas, rather than being re-used where possible using the $ref keyword.

impl PartialEq for StoredSimulation

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

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 StoredSimulation