Struct Design 

#[non_exhaustive]
pub struct Design {
    pub rocket: Rocket,
    pub motors: Motors,
    pub recovery: Recovery,
    pub simulations: Vec<StoredSimulation>,
    pub extensions: Extensions,
}

A .ork design read whole: its rocket, carrying every motor configuration hpr can fly as written, and everything the file says about its motors.

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.

rocket: Rocket

The rocket, as rocket reads it, with Rocket::configurations holding the configurations in Design::motors that were not left out, each motor lit as the file says. A configuration whose MotorConfiguration::staging is set must be flown with that separation (hpr::ork::separation): without it the stack carries its booster to the ground with the sustainer lit on it.

motors: Motors

Every motor configuration in the file, flown or not.

recovery: Recovery

When each parachute and streamer opens and each stage separates.

simulations: Vec<StoredSimulation>

The simulations OpenRocket last ran on the design, with their conditions and results.

extensions: Extensions

What the file holds that hpr does not model, kept whole for an export to put back.

Implementations

impl Design

pub fn new( rocket: Rocket, motors: Motors, recovery: Recovery, simulations: Vec<StoredSimulation>, extensions: Extensions, ) -> Self

A design from its parts, as the hpr design format holds them (hpr_format::DesignFile).

pub fn is_reduced(&self) -> bool

Whether the rocket is reduced: the file describes parts of it (a pod, a parallel stage, a part hpr cannot shape) that are kept in Design::extensions rather than read into it.

The flag is on the Design, not on Design::rocket: check it before using the rocket on its own. A part read as something simpler, such as a cluster of tubes read as one, does not make a design reduced; its warning keeps every configuration of it from flying (ADR-055, the rule for which configurations fly).

pub fn reference_exclusion( &self, simulation: &StoredSimulation, ) -> Option<StoredReferenceExclusion>

Returns why simulation cannot be used as a reference for this design.

This combines the stored-result screen with hpr’s design-reproduction screen. Use StoredSimulation::reference_exclusion and Self::reproduction_exclusion separately when those two questions need to be reported independently.

pub fn reproduction_exclusion( &self, simulation: &StoredSimulation, ) -> Option<StoredReferenceExclusion>

Returns why hpr cannot reproduce the design named by a stored launch configuration.

This is deliberately separate from StoredSimulation::reference_exclusion: a complete OpenRocket result can be a useful stored reference even when hpr does not yet have its motor curve or full airframe model. A caller that needs a result hpr can fly should apply both classifiers.

Trait Implementations

impl Clone for Design

fn clone(&self) -> Design

Returns a duplicate of the value.

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

Performs copy-assignment from source.

impl Debug for Design

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

Formats the value using the given formatter.

impl<'de> Deserialize<'de> for Design

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

where __D: Deserializer<'de>,

Deserialize this value from the given Serde deserializer.

impl JsonSchema for Design

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 Design

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

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 Design