igc 0.2.2

A fast, minimal parser for IGC flight recorder files
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

use std::fmt;

use crate::util::{DisplayOption, ParseError, Time};

/// Describes an event logged during the flight, associated with the B Record immediately
/// following.
///
/// An official Event needs a B Record with the same timestamp.
#[derive(Debug, PartialEq, Eq)]
pub struct ERecord<'a> {
    pub time: Time,
    pub mnemonic: &'a str,
    pub text: Option<&'a str>,
}

impl<'a> ERecord<'a> {
    pub fn parse(line: &'a str) -> Result<Self, ParseError> {
        if line.len() < 10 {
            return Err(ParseError::SyntaxError);
        }
        if !line.bytes().take(10).all(|b| b.is_ascii()) {
            return Err(ParseError::NonASCIICharacters);
        }

        assert_eq!(line.as_bytes()[0], b'E');

        let time = line[1..7].parse()?;
        let mnemonic = &line[7..10];

        let text = if line.len() > 10 {
            Some(&line[10..])
        } else {
            None
        };

        Ok(ERecord {
            time,
            mnemonic,
            text,
        })
    }
}

impl<'a> fmt::Display for ERecord<'a> {
    fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
        write!(
            f,
            "E{time}{mnemonic}{text}",
            time = self.time,
            mnemonic = self.mnemonic,
            text = DisplayOption(self.text)
        )
    }
}

#[cfg(test)]
mod tests {
    use super::*;

    #[test]
    fn erecord_parse() {
        let example_line = "E120515FOOText";
        let parsed = ERecord::parse(example_line).unwrap();
        let expected = ERecord {
            time: Time::from_hms(12, 5, 15),
            mnemonic: "FOO",
            text: Some("Text"),
        };

        assert_eq!(parsed, expected);
    }

    #[test]
    fn parse_with_invalid_char_boundary() {
        assert!(ERecord::parse("Eⶠ𑛀  ").is_err());
    }

    #[test]
    fn erecord_format() {
        let expected_string = "E120515FOOText";
        let record = ERecord {
            time: Time::from_hms(12, 5, 15),
            mnemonic: "FOO",
            text: Some("Text"),
        };

        assert_eq!(format!("{}", record), expected_string);
    }

    proptest! {
        #[test]
        #[allow(unused_must_use)]
        fn parse_doesnt_crash(s in "E\\PC*") {
            ERecord::parse(&s);
        }
    }
}