fix(taws_minimal): Refactor Constraint and AircraftStateConstraints

taws_minimal/tests/cucumber.rs

@@ -70,11 +70,11 @@ fn given_height_above_terrain(world: &mut MyWorld, height_above_terrain: Constra
 
     let unit = Length::new::<length::foot>(1.0);
     let height_above_terrain = match height_above_terrain {
-        Constraint::AtLeast(p, a) => Constraint::AtLeast(p, a * unit),
-        Constraint::AtMost(p, a) => Constraint::AtMost(p, a * unit),
-        Constraint::Equal(p, a) => Constraint::Equal(p, a * unit),
-        Constraint::InRange(p, a, b) => Constraint::InRange(p, a * unit, b * unit),
-        Constraint::NotInRange(p, a, b) => Constraint::NotInRange(p, a * unit, b * unit),
+        Constraint::AtLeast(a) => Constraint::AtLeast(a * unit),
+        Constraint::AtMost(a) => Constraint::AtMost(a * unit),
+        Constraint::Equal(a) => Constraint::Equal(a * unit),
+        Constraint::InRange(a, b) => Constraint::InRange(a * unit, b * unit),
+        Constraint::NotInRange(a, b) => Constraint::NotInRange(a * unit, b * unit),
     };
 
     world.constraints[world.phase].add_altitude_ground_constraint(height_above_terrain);
@@ -86,11 +86,11 @@ fn when_rate_of_descent(world: &mut MyWorld, rate_of_descent: ConstraintParamete
 
     let unit = Velocity::new::<velocity::foot_per_minute>(-1.0);
     let climb_rate = match rate_of_descent {
-        Constraint::AtLeast(p, a) => Constraint::AtMost(p, a * unit),
-        Constraint::AtMost(p, a) => Constraint::AtLeast(p, a * unit),
-        Constraint::Equal(p, a) => Constraint::Equal(p, a * unit),
-        Constraint::InRange(p, a, b) => Constraint::InRange(p, b * unit, a * unit),
-        Constraint::NotInRange(p, a, b) => Constraint::NotInRange(p, b * unit, a * unit),
+        Constraint::AtLeast(a) => Constraint::AtMost(a * unit),
+        Constraint::AtMost(a) => Constraint::AtLeast(a * unit),
+        Constraint::Equal(a) => Constraint::Equal(a * unit),
+        Constraint::InRange(a, b) => Constraint::InRange(b * unit, a * unit),
+        Constraint::NotInRange(a, b) => Constraint::NotInRange(b * unit, a * unit),
     };
 
     world.constraints[world.phase].add_climb_rate_constraint(climb_rate);
@@ -102,11 +102,11 @@ fn when_height_above_terrain(world: &mut MyWorld, height_above_ground: Constrain
 
     let unit = Length::new::<length::foot>(1.0);
     let height_above_ground = match height_above_ground {
-        Constraint::AtLeast(p, a) => Constraint::AtLeast(p, a * unit),
-        Constraint::AtMost(p, a) => Constraint::AtMost(p, a * unit),
-        Constraint::Equal(p, a) => Constraint::Equal(p, a * unit),
-        Constraint::InRange(p, a, b) => Constraint::InRange(p, a * unit, b * unit),
-        Constraint::NotInRange(p, a, b) => Constraint::NotInRange(p, a * unit, b * unit),
+        Constraint::AtLeast(a) => Constraint::AtLeast(a * unit),
+        Constraint::AtMost(a) => Constraint::AtMost(a * unit),
+        Constraint::Equal(a) => Constraint::Equal(a * unit),
+        Constraint::InRange(a, b) => Constraint::InRange(a * unit, b * unit),
+        Constraint::NotInRange(a, b) => Constraint::NotInRange(a * unit, b * unit),
     };
 
     world.constraints[world.phase].add_altitude_ground_constraint(height_above_ground);

taws_minimal/tests/util/constraints/aircraft_state_constraints.rs

@@ -0,0 +1,126 @@
+use opentaws::prelude::*;
+use uom::si::f64::{Angle, Length, Velocity};
+
+use super::{constraint_enforcement, Constraint, ConstraintEnforcer};
+
+#[derive(Clone, Default, PartialEq)]
+pub struct AircraftStateConstraints {
+    altitude: Option<Constraint<Length>>,
+    altitude_ground: Option<Constraint<Length>>,
+    climb_rate: Option<Constraint<Velocity>>,
+    speed_air: Option<Constraint<Velocity>>,
+    heading: Option<Constraint<Angle>>,
+    pitch: Option<Constraint<Angle>>,
+    roll: Option<Constraint<Angle>>,
+
+    steep_approach: bool,
+    precision_approach: bool,
+    go_around: bool,
+    take_off: bool,
+}
+
+impl AircraftStateConstraints {
+    fn apply<Q, TEnforcer>(constraint: &Option<Constraint<Q>>, state: &mut Q)
+    where
+        Q: Copy
+            + PartialOrd
+            + PartialEq<Q>
+            + std::ops::Add<Output = Q>
+            + std::ops::Rem<Output = Q>
+            + std::ops::Sub<Output = Q>
+            + constraint_enforcement::Abs
+            + std::fmt::Debug,
+        TEnforcer: ConstraintEnforcer<Q> + Default,
+    {
+        if let Some(constraint) = constraint {
+            constraint.apply_to::<TEnforcer>(state);
+            constraint.check(*state);
+        }
+    }
+
+    pub fn apply_to<TEnforcer>(&self, state: &mut AircraftState)
+    where
+        TEnforcer: ConstraintEnforcer<Length>
+            + ConstraintEnforcer<Velocity>
+            + ConstraintEnforcer<Angle>
+            + Default,
+    {
+        Self::apply::<Length, TEnforcer>(&self.altitude, &mut state.altitude);
+        Self::apply::<Length, TEnforcer>(&self.altitude_ground, &mut state.altitude_ground);
+        Self::apply::<Velocity, TEnforcer>(&self.climb_rate, &mut state.climb_rate);
+        Self::apply::<Velocity, TEnforcer>(&self.speed_air, &mut state.speed_air);
+        Self::apply::<Angle, TEnforcer>(&self.heading, &mut state.heading);
+        Self::apply::<Angle, TEnforcer>(&self.pitch, &mut state.pitch);
+        Self::apply::<Angle, TEnforcer>(&self.roll, &mut state.roll);
+
+        state.steep_approach = self.steep_approach;
+        state.precision_approach = self.precision_approach;
+        state.go_around = self.go_around;
+        state.take_off = self.take_off;
+    }
+
+    pub fn add_altitude_constraint(&mut self, c: Constraint<Length>) {
+        self.altitude = match &self.altitude {
+            Some(altitude) => Some(altitude.merge(&c).unwrap()),
+            None => Some(c),
+        }
+    }
+
+    pub fn add_altitude_ground_constraint(&mut self, c: Constraint<Length>) {
+        self.altitude_ground = match &self.altitude_ground {
+            Some(altitude_gnd) => Some(altitude_gnd.merge(&c).unwrap()),
+            None => Some(c),
+        }
+    }
+
+    pub fn add_climb_rate_constraint(&mut self, c: Constraint<Velocity>) {
+        self.climb_rate = match &self.climb_rate {
+            Some(climb_rate) => Some(climb_rate.merge(&c).unwrap()),
+            None => Some(c),
+        }
+    }
+
+    pub fn add_speed_air_constraint(&mut self, c: Constraint<Velocity>) {
+        self.speed_air = match &self.speed_air {
+            Some(speed_air) => Some(speed_air.merge(&c).unwrap()),
+            None => Some(c),
+        }
+    }
+
+    pub fn add_heading_constraint(&mut self, c: Constraint<Angle>) {
+        self.heading = match &self.heading {
+            Some(heading) => Some(heading.merge(&c).unwrap()),
+            None => Some(c),
+        }
+    }
+
+    pub fn add_pitch_constraint(&mut self, c: Constraint<Angle>) {
+        self.pitch = match &self.pitch {
+            Some(pitch) => Some(pitch.merge(&c).unwrap()),
+            None => Some(c),
+        }
+    }
+
+    pub fn add_roll_constraint(&mut self, c: Constraint<Angle>) {
+        self.roll = match &self.roll {
+            Some(roll) => Some(roll.merge(&c).unwrap()),
+            None => Some(c),
+        }
+    }
+
+    pub fn add_steep_approach_constraint(&mut self, c: bool) {
+        self.steep_approach = c;
+    }
+
+    pub fn add_precision_approach_constraint(&mut self, c: bool) {
+        self.precision_approach = c;
+    }
+
+    pub fn add_go_around_constraint(&mut self, c: bool) {
+        self.go_around = c;
+    }
+
+    pub fn add_take_off_constraint(&mut self, c: bool) {
+        self.take_off = c;
+    }
+}