binex/message/record/ephemeris/gps/
raw.rs

1//! Raw GPS Ephemeris
2use crate::Error;
3
4#[derive(Debug, Clone, PartialEq)]
5pub struct GPSRaw {
6    pub svid1: u8,
7    pub uint1: u8,
8    pub sint4: i32,
9    bytes: [u8; 72],
10}
11
12impl Default for GPSRaw {
13    fn default() -> Self {
14        Self {
15            svid1: 0,
16            uint1: 0,
17            sint4: 0,
18            bytes: [0; 72],
19        }
20    }
21}
22
23impl GPSRaw {
24    /// Builds new Raw GPS Ephemeris message
25    pub fn new() -> Self {
26        Self::default()
27    }
28
29    pub(crate) const fn encoding_size() -> usize {
30        78
31    }
32
33    pub(crate) fn decode(big_endian: bool, buf: &[u8]) -> Result<Self, Error> {
34        if buf.len() < Self::encoding_size() {
35            return Err(Error::NotEnoughBytes);
36        }
37
38        let svid1 = buf[0];
39        let uint1 = buf[1];
40
41        let sint4 = if big_endian {
42            i32::from_be_bytes([buf[2], buf[3], buf[4], buf[5]])
43        } else {
44            i32::from_le_bytes([buf[2], buf[3], buf[4], buf[5]])
45        };
46
47        let mut bytes = [0; 72];
48        bytes.clone_from_slice(&buf[6..78]);
49
50        Ok(Self {
51            svid1,
52            uint1,
53            sint4,
54            bytes,
55        })
56    }
57
58    pub(crate) fn encode(&self, big_endian: bool, buf: &mut [u8]) -> Result<usize, Error> {
59        let size = Self::encoding_size();
60        if buf.len() < size {
61            Err(Error::NotEnoughBytes)
62        } else {
63            buf[0] = self.svid1;
64            buf[1] = self.uint1;
65
66            let bytes = if big_endian {
67                self.sint4.to_be_bytes()
68            } else {
69                self.sint4.to_le_bytes()
70            };
71
72            buf[2..6].copy_from_slice(&bytes);
73            buf[6..78].copy_from_slice(&self.bytes);
74
75            Ok(size)
76        }
77    }
78}
79
80#[cfg(test)]
81mod test {
82    use super::*;
83
84    #[test]
85    fn gps_raw() {
86        for big_endian in [true, false] {
87            let buf = [0; 64];
88            let decode = GPSRaw::decode(big_endian, &buf);
89            assert!(decode.is_err());
90
91            let mut buf = [0; 78];
92            buf[0] = 10;
93            buf[1] = 1;
94            buf[6] = 10;
95            buf[7] = 11;
96            buf[6 + 71] = 123;
97
98            let decoded = GPSRaw::decode(big_endian, &buf).unwrap();
99
100            assert_eq!(decoded.svid1, 10);
101            assert_eq!(decoded.uint1, 1);
102            assert_eq!(decoded.bytes.len(), 72);
103
104            assert_eq!(decoded.bytes[0], 10);
105            assert_eq!(decoded.bytes[1], 11);
106            assert_eq!(decoded.bytes[71], 123);
107
108            let mut encoded = [0; 78];
109            let size = decoded.encode(big_endian, &mut encoded).unwrap();
110            assert_eq!(size, 78);
111            assert_eq!(buf, encoded)
112        }
113    }
114}