ais 0.12.0

An Automatic Identification System (AIS) parser library
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

//! Safety-Related Broadcast Message (type 14)

use super::parsers::*;
use super::AisMessageType;
use crate::errors::Result;
use nom::bits::{bits, complete::take as take_bits};
use nom::IResult;

#[derive(Debug, PartialEq)]
pub struct SafetyRelatedBroadcastMessage {
    pub message_type: u8,
    pub repeat_indicator: u8,
    pub mmsi: u32,
    pub text: AsciiString,
}

impl<'a> AisMessageType<'a> for SafetyRelatedBroadcastMessage {
    fn name(&self) -> &'static str {
        "Safety-Related Broadcast Message"
    }

    fn parse(data: &'a [u8]) -> Result<Self> {
        let (_, report) = parse_base(data)?;
        Ok(report)
    }
}

fn parse_base(data: &[u8]) -> IResult<&[u8], SafetyRelatedBroadcastMessage> {
    bits(move |data| -> IResult<_, _> {
        let (data, message_type) = take_bits(6u8)(data)?;
        let (data, repeat_indicator) = take_bits(2u8)(data)?;
        let (data, mmsi) = take_bits(30u32)(data)?;
        let (data, _spare) = take_bits::<_, u8, _, _>(2u8)(data)?;

        // Ensure there are enough bits remaining for text
        let remaining_bits = remaining_bits(data);
        if remaining_bits < 6 {
            return Err(nom::Err::Error(nom::error::Error::new(
                data,
                nom::error::ErrorKind::Eof,
            )));
        }

        let (data, text) = parse_6bit_ascii(data, remaining_bits)?;

        Ok((
            data,
            SafetyRelatedBroadcastMessage {
                message_type,
                repeat_indicator,
                mmsi,
                text,
            },
        ))
    })(data)
}

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

    #[test]
    fn test_type14_example() {
        let bytestream = b">5?Per18=HB1U:1@E=B0m<L";
        let bitstream = crate::messages::unarmor(bytestream, 2).unwrap();
        let report = SafetyRelatedBroadcastMessage::parse(bitstream.as_ref()).unwrap();

        assert_eq!(report.message_type, 14);
        assert_eq!(report.repeat_indicator, 0);
        assert_eq!(report.mmsi, 351809000);
        assert_eq!(report.text, "RCVD YR TEST MSG");
    }
}