rust_nmea 1.2.6

NMEA (0183) parser and information library for Rust.
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

use crate::types::{CardinalDirection, Command, Error};

/// DTM (Datum Reference)
#[derive(Debug, Clone, PartialEq)]
pub struct DTM {
    /// Local datum
    pub local_datum_code: String,
    /// Local datum sub division code
    pub local_datum_sub_division_code: String,
    /// Latitude offset, in minutes
    pub latitude_offset: f64,
    /// N=North/S=South indicator
    pub northing_indicator: CardinalDirection,
    /// Longitude offset, in minutes
    pub longitude_offset: f64,
    /// E=East/W=West indicator
    pub easting_indicator: CardinalDirection,
    /// Altitude offset, in meters
    pub altitude_offset: f64,
    /// Reference datum code
    pub reference_datum_code: String,
}

impl Default for DTM {
    fn default() -> Self {
        Self {
            local_datum_code: Default::default(),
            local_datum_sub_division_code: Default::default(),
            latitude_offset: Default::default(),
            northing_indicator: CardinalDirection::North,
            longitude_offset: Default::default(),
            easting_indicator: CardinalDirection::East,
            altitude_offset: Default::default(),
            reference_datum_code: Default::default(),
        }
    }
}

impl Command<DTM> for DTM {
    fn parse_command(&self, command: Vec<String>) -> Result<DTM, Error> {
        let local_datum_code = command[0].clone();
        let local_datum_sub_division_code = command[1].clone();
        let latitude_offset = command[2].parse::<f64>()?;
        let northing_indicator = match command[3].chars().next() {
            Some(e) => e,
            None => return Err(Error::ParseError("Invalid northing indicator".to_string())),
        };

        let northing_indicator = match CardinalDirection::from_char(northing_indicator) {
            Some(e) => e,
            None => return Err(Error::ParseError("Invalid northing indicator".to_string())),
        };

        let longitude_offset = command[4].parse::<f64>()?;
        let easting_indicator = match command[5].chars().next() {
            Some(e) => e,
            None => return Err(Error::ParseError("Invalid easting indicator".to_string())),
        };

        let easting_indicator = match CardinalDirection::from_char(easting_indicator) {
            Some(e) => e,
            None => return Err(Error::ParseError("Invalid easting indicator".to_string())),
        };

        let altitude_offset = command[6].parse::<f64>()?;
        let reference_datum_code = command[7].clone();

        Ok(DTM {
            local_datum_code,
            local_datum_sub_division_code,
            latitude_offset,
            northing_indicator,
            longitude_offset,
            easting_indicator,
            altitude_offset,
            reference_datum_code,
        })
    }
}