rtps_parser/rtps/messages/submessages/
heartbeat_frag.rs

1use crate::rtps::{
2    messages::{
3        overall_structure::{
4            RtpsMap, Submessage, SubmessageHeader, SubmessageHeaderRead, SubmessageHeaderWrite,
5        },
6        submessage_elements::SubmessageElement,
7        types::{Count, FragmentNumber, SubmessageKind},
8    },
9    types::{EntityId, SequenceNumber},
10};
11
12#[derive(Debug, PartialEq, Eq)]
13pub struct HeartbeatFragSubmessageRead<'a> {
14    data: &'a [u8],
15}
16
17impl SubmessageHeader for HeartbeatFragSubmessageRead<'_> {
18    fn submessage_header(&self) -> SubmessageHeaderRead {
19        SubmessageHeaderRead::new(self.data)
20    }
21}
22
23impl<'a> HeartbeatFragSubmessageRead<'a> {
24    pub fn new(data: &'a [u8]) -> Self {
25        Self { data }
26    }
27
28    pub fn _reader_id(&self) -> EntityId {
29        self.map(&self.data[4..])
30    }
31
32    pub fn writer_id(&self) -> EntityId {
33        self.map(&self.data[8..])
34    }
35
36    pub fn _writer_sn(&self) -> SequenceNumber {
37        self.map(&self.data[12..])
38    }
39
40    pub fn _last_fragment_num(&self) -> FragmentNumber {
41        self.map(&self.data[20..])
42    }
43
44    pub fn count(&self) -> Count {
45        self.map(&self.data[24..])
46    }
47}
48
49#[derive(Debug, PartialEq, Eq)]
50pub struct HeartbeatFragSubmessageWrite<'a> {
51    submessage_elements: [SubmessageElement<'a>; 5],
52}
53impl HeartbeatFragSubmessageWrite<'_> {
54    pub fn _new(
55        reader_id: EntityId,
56        writer_id: EntityId,
57        writer_sn: SequenceNumber,
58        last_fragment_num: FragmentNumber,
59        count: Count,
60    ) -> Self {
61        Self {
62            submessage_elements: [
63                SubmessageElement::EntityId(reader_id),
64                SubmessageElement::EntityId(writer_id),
65                SubmessageElement::SequenceNumber(writer_sn),
66                SubmessageElement::FragmentNumber(last_fragment_num),
67                SubmessageElement::Count(count),
68            ],
69        }
70    }
71}
72
73impl<'a> Submessage<'a> for HeartbeatFragSubmessageWrite<'a> {
74    type SubmessageList = &'a [SubmessageElement<'a>];
75
76    fn submessage_header(
77        &self,
78        octets_to_next_header: u16,
79    ) -> crate::rtps::messages::overall_structure::SubmessageHeaderWrite {
80        SubmessageHeaderWrite::new(SubmessageKind::HEARTBEAT_FRAG, &[], octets_to_next_header)
81    }
82
83    fn submessage_elements(&'a self) -> Self::SubmessageList {
84        &self.submessage_elements
85    }
86}
87
88#[cfg(test)]
89mod tests {
90    use super::*;
91    use crate::rtps::{
92        messages::overall_structure::{into_bytes_vec, RtpsSubmessageWriteKind},
93        types::{USER_DEFINED_READER_GROUP, USER_DEFINED_READER_NO_KEY},
94    };
95
96    #[test]
97    fn serialize_heart_beat() {
98        let submessage =
99            RtpsSubmessageWriteKind::HeartbeatFrag(HeartbeatFragSubmessageWrite::_new(
100                EntityId::new([1, 2, 3], USER_DEFINED_READER_NO_KEY),
101                EntityId::new([6, 7, 8], USER_DEFINED_READER_GROUP),
102                SequenceNumber::from(5),
103                7,
104                2,
105            ));
106        #[rustfmt::skip]
107        assert_eq!(into_bytes_vec(submessage), vec![
108                0x13_u8, 0b_0000_0001, 24, 0, // Submessage header
109                1, 2, 3, 4, // readerId: value[4]
110                6, 7, 8, 9, // writerId: value[4]
111                0, 0, 0, 0, // writerSN: SequenceNumber: high
112                5, 0, 0, 0, // writerSN: SequenceNumber: low
113                7, 0, 0, 0, // lastFragmentNum
114                2, 0, 0, 0, // count: Count
115            ]
116        );
117    }
118
119    #[test]
120    fn deserialize_heart_beat_frag() {
121        #[rustfmt::skip]
122        let submessage = HeartbeatFragSubmessageRead::new(&[
123            0x13_u8, 0b_0000_0001, 24, 0, // Submessage header
124            1, 2, 3, 4, // readerId: value[4]
125            6, 7, 8, 9, // writerId: value[4]
126            0, 0, 0, 0, // writerSN: SequenceNumber: high
127            5, 0, 0, 0, // writerSN: SequenceNumber: low
128            7, 0, 0, 0, // lastFragmentNum
129            2, 0, 0, 0, // count: Count
130        ]);
131
132        let expected_reader_id = EntityId::new([1, 2, 3], USER_DEFINED_READER_NO_KEY);
133        let expected_writer_id = EntityId::new([6, 7, 8], USER_DEFINED_READER_GROUP);
134        let expected_writer_sn = SequenceNumber::from(5);
135        let expected_last_fragment_num = 7;
136        let expected_count = 2;
137
138        assert_eq!(expected_reader_id, submessage._reader_id());
139        assert_eq!(expected_writer_id, submessage.writer_id());
140        assert_eq!(expected_writer_sn, submessage._writer_sn());
141        assert_eq!(expected_last_fragment_num, submessage._last_fragment_num());
142        assert_eq!(expected_count, submessage.count());
143    }
144}