flarmnet 0.2.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

use crate::lx::cipher::encrypt;
use crate::File;
use minidom::quick_xml;
use minidom::quick_xml::events::{BytesDecl, BytesEnd, BytesStart, BytesText, Event};
use minidom::quick_xml::Writer;
use std::io::Cursor;
use std::string::FromUtf8Error;
use thiserror::Error;

#[derive(Error, Debug)]
pub enum EncodeError {
    #[error(transparent)]
    Xml(#[from] quick_xml::Error),
    #[error(transparent)]
    Utf8(#[from] FromUtf8Error),
}

/// Encodes a FlarmNet file in LX format.
///
/// # 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::lx::encode_file(&file);
/// assert!(result.is_ok());
/// ```
pub fn encode_file(file: &File) -> Result<String, EncodeError> {
    let mut writer = Writer::new_with_indent(Cursor::new(Vec::new()), 9u8, 1);

    writer.write_event(Event::Decl(BytesDecl::new(b"1.0", Some(b"UTF-8"), None)))?;

    let version = format!("{:06x?}", file.version);
    writer.write_event(Event::Start(
        BytesStart::borrowed_name(b"FLARMNET")
            .with_attributes(vec![("Version".as_bytes(), version.as_bytes())]),
    ))?;
    for record in &file.records {
        writer.write_event(Event::Start(
            BytesStart::borrowed_name(b"FLARMDATA")
                .with_attributes(vec![("FlarmID".as_bytes(), record.flarm_id.as_bytes())]),
        ))?;

        writer.write_event(Event::Start(BytesStart::borrowed_name(b"NAME")))?;
        writer.write_event(Event::Text(BytesText::from_plain_str(&record.pilot_name)))?;
        writer.write_event(Event::End(BytesEnd::borrowed(b"NAME")))?;

        writer.write_event(Event::Start(BytesStart::borrowed_name(b"AIRFIELD")))?;
        writer.write_event(Event::Text(BytesText::from_plain_str(&record.airfield)))?;
        writer.write_event(Event::End(BytesEnd::borrowed(b"AIRFIELD")))?;

        writer.write_event(Event::Start(BytesStart::borrowed_name(b"TYPE")))?;
        writer.write_event(Event::Text(BytesText::from_plain_str(&record.plane_type)))?;
        writer.write_event(Event::End(BytesEnd::borrowed(b"TYPE")))?;

        writer.write_event(Event::Start(BytesStart::borrowed_name(b"REG")))?;
        writer.write_event(Event::Text(BytesText::from_plain_str(&record.registration)))?;
        writer.write_event(Event::End(BytesEnd::borrowed(b"REG")))?;

        writer.write_event(Event::Start(BytesStart::borrowed_name(b"COMPID")))?;
        writer.write_event(Event::Text(BytesText::from_plain_str(&record.call_sign)))?;
        writer.write_event(Event::End(BytesEnd::borrowed(b"COMPID")))?;

        writer.write_event(Event::Start(BytesStart::borrowed_name(b"FREQUENCY")))?;
        writer.write_event(Event::Text(BytesText::from_plain_str(&record.frequency)))?;
        writer.write_event(Event::End(BytesEnd::borrowed(b"FREQUENCY")))?;

        writer.write_event(Event::End(BytesEnd::borrowed(b"FLARMDATA")))?;
    }
    writer.write_event(Event::End(BytesEnd::borrowed(b"FLARMNET")))?;

    let xml = String::from_utf8(writer.into_inner().into_inner())?;

    Ok(encrypt(&xml)?)
}