Merge pull request #105 from NatLabRockies/rjf/expected-maxspeed

Rjf/expected maxspeed

Author: robfitzgerald

rust/bambam-omf/src/collection/record/mod.rs

@@ -19,7 +19,7 @@ pub use transportation_segment::{
     SegmentAccessType, SegmentClass, SegmentDestination, SegmentFullType, SegmentHeading,
     SegmentLengthUnit, SegmentMode, SegmentRecognized, SegmentSpeedLimit, SegmentSpeedUnit,
     SegmentSubclass, SegmentSubtype, SegmentUnit, SegmentUsing, SegmentVehicleComparator,
-    SegmentVehicleDimension, TransportationSegmentRecord,
+    SegmentVehicleDimension, SpeedLimitWithUnit, TransportationSegmentRecord,
 };
 
 // Common structs and functions for many record types

rust/bambam-omf/src/collection/record/transportation_segment.rs

@@ -921,8 +921,8 @@ impl SegmentSpeedLimit {
 
 #[derive(Debug, Serialize, Deserialize, Clone)]
 pub struct SpeedLimitWithUnit {
-    value: i32,
-    unit: SegmentSpeedUnit,
+    pub value: i32,
+    pub unit: SegmentSpeedUnit,
 }
 
 impl SpeedLimitWithUnit {

rust/bambam-omf/src/graph/segment_split.rs

@@ -6,7 +6,7 @@ use routee_compass_core::model::network::{Edge, EdgeId, EdgeListId, Vertex, Vert
 
 use crate::{
     collection::{
-        record::SegmentHeading, OvertureMapsCollectionError, SegmentFullType,
+        record::SegmentHeading, OvertureMapsCollectionError, SegmentFullType, SegmentSpeedLimit,
         TransportationSegmentRecord,
     },
     graph::connector_in_segment::ConnectorInSegment,
@@ -216,14 +216,7 @@ impl SegmentSplit {
                 // retain speed limits with no heading or with a matching heading
                 let speed_limits_with_heading = speed_limits
                     .iter()
-                    .filter(|s| match s.when.as_ref() {
-                        Some(access) => match access.heading.as_ref() {
-                            None => true,
-                            Some(h) if h == heading => true,
-                            _ => false,
-                        },
-                        None => true,
-                    })
+                    .filter(|s| has_max_speed_for_heading(s, heading))
                     .collect_vec();
 
                 // Compute the intersecting portion of each limit
@@ -350,3 +343,55 @@ impl SegmentSplit {
         }
     }
 }
+
+/// helper function which confirms that speed data exists and that it matches the current heading
+fn has_max_speed_for_heading(s: &SegmentSpeedLimit, heading: &SegmentHeading) -> bool {
+    // no max speed? return early
+    if s.max_speed.as_ref().is_none() {
+        return false;
+    }
+
+    let when = match s.when.as_ref() {
+        Some(w) => w,
+        None => return true, // no access restrictions to apply
+    };
+
+    match when.heading.as_ref() {
+        None => true, // no heading restrictions to apply
+        Some(h) if h == heading => true,
+        _ => false,
+    }
+}
+
+#[cfg(test)]
+mod test {
+    use crate::collection::{
+        record::{SegmentHeading, SpeedLimitWithUnit},
+        SegmentAccessRestrictionWhen, SegmentSpeedLimit, SegmentSpeedUnit,
+    };
+
+    #[test]
+    fn no_maxspeed_entry() {
+        // unexpected case where the record has a min speed but no max speed
+        let record = SegmentSpeedLimit {
+            min_speed: Some(SpeedLimitWithUnit {
+                value: 35,
+                unit: SegmentSpeedUnit::Mph,
+            }),
+            max_speed: None,
+            is_max_speed_variable: None,
+            when: Some(SegmentAccessRestrictionWhen {
+                during: None,
+                heading: Some(SegmentHeading::Backward),
+                using: None,
+                recognized: None,
+                mode: None,
+                vehicle: None,
+            }),
+            between: Some(vec![0.0, 0.418244116]),
+        };
+        let heading = SegmentHeading::Forward;
+        let result = super::has_max_speed_for_heading(&record, &heading);
+        assert!(!result)
+    }
+}