phoxal 0.66.0

Phoxal - production-oriented autonomous robot framework: the one framework library, holding the runtime engine, the api contract tree, the typed bus, the canonical model, and the bundle.
Documentation 
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136

crate::endpoints! {
    sample: Sample<Sample>;
}

#[derive(
    phoxal_macros::DescribeWire,
    Copy,
    Eq,
    Clone,
    Debug,
    PartialEq,
    serde::Serialize,
    serde::Deserialize,
)]
#[serde(rename_all = "snake_case")]
pub enum SensorHealth {
    Nominal,
    Degraded,
    Fault,
}
#[derive(
    phoxal_macros::DescribeWire, Copy, Clone, Debug, PartialEq, serde::Serialize, serde::Deserialize,
)]
pub struct Limits {
    pub min_m: f32,
    pub max_m: f32,
}
#[derive(
    phoxal_macros::DescribeWire, Copy, Clone, Debug, PartialEq, serde::Serialize, serde::Deserialize,
)]
pub struct SampleQuality {
    pub valid: bool,
    pub confidence: Option<f32>,
}
#[derive(
    phoxal_macros::DescribeWire, Clone, Debug, PartialEq, serde::Serialize, serde::Deserialize,
)]
#[serde(try_from = "SampleWire")]
pub struct Sample {
    pub distance_m: f32,
    pub limits: Option<Limits>,
    pub quality: Option<SampleQuality>,
    pub health: SensorHealth,
}
#[derive(serde::Deserialize)]
struct SampleWire {
    distance_m: f32,
    limits: Option<Limits>,
    quality: Option<SampleQuality>,
    health: SensorHealth,
}
#[derive(Debug, Clone, PartialEq, Eq)]
pub struct InvalidSample(&'static str);
impl std::fmt::Display for InvalidSample {
    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
        f.write_str(self.0)
    }
}
impl std::error::Error for InvalidSample {}
impl Sample {
    pub fn try_new(
        distance_m: f32,
        limits: Option<Limits>,
        quality: Option<SampleQuality>,
        health: SensorHealth,
    ) -> Result<Self, InvalidSample> {
        if !distance_m.is_finite() || distance_m < 0.0 {
            return Err(InvalidSample(
                "range distance must be finite and nonnegative",
            ));
        }
        if let Some(l) = limits
            && !(l.min_m.is_finite()
                && l.max_m.is_finite()
                && l.min_m >= 0.0
                && l.min_m <= l.max_m
                && distance_m >= l.min_m
                && distance_m <= l.max_m)
        {
            return Err(InvalidSample(
                "range limits must be finite, ordered, and contain distance",
            ));
        }
        if !quality
            .and_then(|q| q.confidence)
            .is_none_or(|c| c.is_finite() && (0.0..=1.0).contains(&c))
        {
            return Err(InvalidSample(
                "range confidence must be finite and in [0, 1]",
            ));
        }
        Ok(Self {
            distance_m,
            limits,
            quality,
            health,
        })
    }
}
impl TryFrom<SampleWire> for Sample {
    type Error = InvalidSample;
    fn try_from(v: SampleWire) -> Result<Self, Self::Error> {
        Self::try_new(v.distance_m, v.limits, v.quality, v.health)
    }
}
#[cfg(test)]
mod tests {
    use super::*;
    #[test]
    fn constructor_requires_ordered_containing_limits() {
        assert!(
            Sample::try_new(
                2.0,
                Some(Limits {
                    min_m: 3.0,
                    max_m: 1.0
                }),
                None,
                SensorHealth::Nominal
            )
            .is_err()
        );
        assert!(
            Sample::try_new(
                2.0,
                Some(Limits {
                    min_m: 0.0,
                    max_m: 1.0
                }),
                None,
                SensorHealth::Nominal
            )
            .is_err()
        );
    }
}