flarmnet 0.6.0

FlarmNet file decoder/encoder
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
137
138
139
140
141
142
143
144

use super::fields::*;
use crate::{File, Record};
use encoding_rs::mem::{encode_latin1_lossy, is_str_latin1};
use std::io::{Cursor, Write};
use thiserror::Error;

#[derive(Error, Debug)]
pub enum EncodeError {
    #[error(transparent)]
    Io(#[from] std::io::Error),
    // the value could not be converted to valid latin1
    #[error("invalid encoding: {0}")]
    InvalidEncoding(String),
}

/// Encodes a FlarmNet file.
///
/// # Examples
///
/// ```
/// # use flarmnet::Record;
/// let file = flarmnet::File {
///     version: 123,
///     records: vec![
///         Record {
///             flarm_id: "3EE3C7".to_string(),
///             pilot_name: "Tobias Bieniek".to_string(),
///             airfield: "EDKA".to_string(),
///             plane_type: "LS6a".to_string(),
///             registration: "D-0816".to_string(),
///             call_sign: "SG".to_string(),
///             frequency: "130.530".to_string(),
///         }
///     ]
/// };
///
/// let result = flarmnet::xcsoar::encode_file(&file).unwrap();
/// assert_eq!(result, br#"00007b
/// 334545334337546f62696173204269656e69656b2020202020202045444b4120202020202020202020202020202020204c5336612020202020202020202020202020202020442d30383136205347203133302e353330
/// "#);
/// ```
pub fn encode_file(file: &File) -> Result<Vec<u8>, EncodeError> {
    let mut writer = Writer::new(Cursor::new(Vec::new()));
    writer.write(file)?;

    let buffer = writer.into_inner().into_inner();

    Ok(buffer)
}

#[derive(Clone)]
pub struct Writer<W: Write> {
    writer: W,
}

impl<W: Write> Writer<W> {
    pub fn new(inner: W) -> Self {
        Self { writer: inner }
    }

    pub fn write(&mut self, file: &File) -> Result<(), EncodeError> {
        self.write_version(file.version)?;
        for record in &file.records {
            self.write_record(record)?;
        }

        Ok(())
    }

    fn write_version(&mut self, version: u32) -> Result<(), EncodeError> {
        self.writer.write_fmt(format_args!("{:06x?}", version))?;
        self.writer.write_all(b"\n")?;

        Ok(())
    }

    fn write_record(&mut self, record: &Record) -> Result<(), EncodeError> {
        self.write_str(&record.flarm_id, FLARM_ID_LENGTH)?;
        self.write_str(&record.pilot_name, PILOT_NAME_LENGTH)?;
        self.write_str(&record.airfield, AIRFIELD_LENGTH)?;
        self.write_str(&record.plane_type, PLANE_TYPE_LENGTH)?;
        self.write_str(&record.registration, REGISTRATION_LENGTH)?;
        self.write_str(&record.call_sign, CALL_SIGN_LENGTH)?;
        self.write_str(&record.frequency, FREQUENCY_LENGTH)?;
        self.writer.write_all(b"\n")?;

        Ok(())
    }

    pub(crate) fn write_str(&mut self, value: &str, length: usize) -> Result<(), EncodeError> {
        if !is_str_latin1(value) {
            return Err(EncodeError::InvalidEncoding(value.to_string()));
        }

        let bytes = encode_latin1_lossy(value);
        for byte in bytes.iter().take(length) {
            self.writer.write_fmt(format_args!("{:02x?}", byte))?;
        }

        let bytes_len = bytes.len();
        if bytes_len < length {
            let placeholders = b"20".repeat(length - bytes_len);
            self.writer.write_all(&placeholders)?;
        }

        Ok(())
    }

    pub fn into_inner(self) -> W {
        self.writer
    }
}

#[cfg(test)]
mod tests {
    use super::{EncodeError, Writer};
    use insta::assert_debug_snapshot;
    use std::io::Cursor;

    fn encode_str(value: &str, length: usize) -> Result<String, EncodeError> {
        let mut writer = Writer::new(Cursor::new(Vec::new()));
        writer.write_str(value, length)?;
        let bytes = writer.into_inner().into_inner();
        Ok(String::from_utf8(bytes).unwrap())
    }

    #[test]
    fn encoding_works() {
        assert_eq!(encode_str("D-4711", 7).unwrap(), "442d3437313120");
        assert_eq!(encode_str("1234567890", 7).unwrap(), "31323334353637");
        assert_eq!(encode_str("Müller", 10).unwrap(), "4dfc6c6c657220202020");
    }

    #[test]
    fn encoding_fails_for_non_latin1() {
        assert_debug_snapshot!(
            encode_str("😅", 7).unwrap_err(),
            @r###"
            InvalidEncoding(
                "😅",
            )
            "###);
    }
}