rtps_parser/rtps/messages/
submessage_elements.rs

1use super::{
2    overall_structure::{FromBytes, WriteBytes},
3    types::{ParameterId, Time},
4};
5
6use crate::{
7    parameter_id_values::PID_SENTINEL,
8    rtps::{
9        messages::types::{Count, FragmentNumber},
10        types::{EntityId, GuidPrefix, Locator, ProtocolVersion, SequenceNumber, VendorId},
11    },
12};
13use std::{
14    io::BufRead,
15    ops::{Index, Range, RangeFrom, RangeTo},
16    sync::Arc,
17};
18///
19/// This files shall only contain the types as listed in the DDS-RTPS Version 2.3
20/// 8.3.5 RTPS SubmessageElements
21///
22
23#[allow(dead_code)]
24#[derive(Debug, PartialEq, Eq)]
25pub enum SubmessageElement<'a> {
26    Count(Count),
27    EntityId(EntityId),
28    FragmentNumber(FragmentNumber),
29    FragmentNumberSet(FragmentNumberSet),
30    GuidPrefix(GuidPrefix),
31    LocatorList(LocatorList),
32    Long(i32),
33    ParameterList(&'a ParameterList),
34    ProtocolVersion(ProtocolVersion),
35    SequenceNumber(SequenceNumber),
36    SequenceNumberSet(SequenceNumberSet),
37    SerializedData(&'a Data),
38    Timestamp(Time),
39    ULong(u32),
40    UShort(u16),
41    VendorId(VendorId),
42}
43
44impl WriteBytes for SubmessageElement<'_> {
45    #[inline]
46    fn write_bytes(&self, buf: &mut [u8]) -> usize {
47        match self {
48            SubmessageElement::Count(e) => e.write_bytes(buf),
49            SubmessageElement::EntityId(e) => e.write_bytes(buf),
50            SubmessageElement::FragmentNumber(e) => e.write_bytes(buf),
51            SubmessageElement::FragmentNumberSet(e) => e.write_bytes(buf),
52            SubmessageElement::GuidPrefix(e) => e.write_bytes(buf),
53            SubmessageElement::LocatorList(e) => e.write_bytes(buf),
54            SubmessageElement::Long(e) => e.write_bytes(buf),
55            SubmessageElement::ParameterList(e) => e.write_bytes(buf),
56            SubmessageElement::ProtocolVersion(e) => e.write_bytes(buf),
57            SubmessageElement::SequenceNumber(e) => e.write_bytes(buf),
58            SubmessageElement::SequenceNumberSet(e) => e.write_bytes(buf),
59            SubmessageElement::SerializedData(e) => e.write_bytes(buf),
60            SubmessageElement::Timestamp(e) => e.write_bytes(buf),
61            SubmessageElement::ULong(e) => e.write_bytes(buf),
62            SubmessageElement::UShort(e) => e.write_bytes(buf),
63            SubmessageElement::VendorId(e) => e.write_bytes(buf),
64        }
65    }
66}
67
68#[derive(Clone, Debug, PartialEq, Eq)]
69pub struct SequenceNumberSet {
70    base: SequenceNumber,
71    num_bits: u32,
72    bitmap: [i32; 8],
73}
74
75impl SequenceNumberSet {
76    pub fn new(base: SequenceNumber, set: impl IntoIterator<Item = SequenceNumber>) -> Self {
77        let mut bitmap = [0; 8];
78        let mut num_bits = 0;
79        for sequence_number in set {
80            let delta_n = <i64>::from(sequence_number - base) as u32;
81            let bitmap_num = delta_n / 32;
82            bitmap[bitmap_num as usize] |= 1 << (31 - delta_n % 32);
83            if delta_n + 1 > num_bits {
84                num_bits = delta_n + 1;
85            }
86        }
87
88        Self {
89            base,
90            num_bits,
91            bitmap,
92        }
93    }
94
95    pub fn base(&self) -> SequenceNumber {
96        self.base
97    }
98
99    pub fn set(&self) -> impl Iterator<Item = SequenceNumber> + '_ {
100        struct SequenceNumberSetIterator<'a> {
101            set: &'a SequenceNumberSet,
102            index: usize,
103        }
104
105        impl Iterator for SequenceNumberSetIterator<'_> {
106            type Item = SequenceNumber;
107
108            fn next(&mut self) -> Option<Self::Item> {
109                while self.index < self.set.num_bits as usize {
110                    let delta_n = self.index;
111                    self.index += 1;
112                    let bitmap_num = delta_n / 32;
113                    let mask = 1 << (31 - delta_n % 32);
114                    if self.set.bitmap[bitmap_num] & mask == mask {
115                        return Some(self.set.base + SequenceNumber::from(delta_n as i64));
116                    }
117                }
118                None
119            }
120        }
121
122        SequenceNumberSetIterator {
123            set: self,
124            index: 0,
125        }
126    }
127}
128
129impl WriteBytes for SequenceNumberSet {
130    #[inline]
131    fn write_bytes(&self, buf: &mut [u8]) -> usize {
132        let number_of_bitmap_elements = ((self.num_bits + 31) / 32) as usize; //In standard referred to as "M"
133
134        self.base.write_bytes(&mut buf[0..]);
135        self.num_bits.write_bytes(&mut buf[8..]);
136        let mut len = 12;
137        for bitmap_element in &self.bitmap[..number_of_bitmap_elements] {
138            bitmap_element.write_bytes(&mut buf[len..]);
139            len += 4;
140        }
141        len
142    }
143}
144
145#[derive(Clone, Debug, PartialEq, Eq)]
146pub struct FragmentNumberSet {
147    base: FragmentNumber,
148    set: Vec<FragmentNumber>,
149}
150
151impl FragmentNumberSet {
152    pub fn new(base: FragmentNumber, set: impl IntoIterator<Item = FragmentNumber>) -> Self {
153        Self {
154            base,
155            set: set.into_iter().collect(),
156        }
157    }
158}
159
160impl WriteBytes for FragmentNumberSet {
161    fn write_bytes(&self, buf: &mut [u8]) -> usize {
162        let mut bitmap = [0; 8];
163        let mut num_bits = 0;
164        for fragment_number in &self.set {
165            let delta_n = *fragment_number - self.base;
166            let bitmap_num = delta_n / 32;
167            bitmap[bitmap_num as usize] |= 1 << (31 - delta_n % 32);
168            if delta_n + 1 > num_bits {
169                num_bits = delta_n + 1;
170            }
171        }
172        let number_of_bitmap_elements = ((num_bits + 31) / 32) as usize; //In standard referred to as "M"
173
174        let mut len = 0;
175        len += self.base.write_bytes(&mut buf[len..]);
176        len += num_bits.write_bytes(&mut buf[len..]);
177
178        for bitmap_element in &bitmap[..number_of_bitmap_elements] {
179            len += bitmap_element.write_bytes(&mut buf[len..]);
180        }
181        len
182    }
183}
184
185#[derive(Clone, Debug, PartialEq, Eq)]
186pub struct LocatorList {
187    value: Vec<Locator>,
188}
189
190impl LocatorList {
191    pub fn new(value: Vec<Locator>) -> Self {
192        Self { value }
193    }
194
195    pub fn value(&self) -> &[Locator] {
196        self.value.as_ref()
197    }
198}
199
200impl WriteBytes for LocatorList {
201    fn write_bytes(&self, buf: &mut [u8]) -> usize {
202        let num_locators = self.value().len() as u32;
203        num_locators.write_bytes(&mut buf[0..]);
204        let mut len = 4;
205        for locator in self.value().iter() {
206            len += locator.write_bytes(&mut buf[len..]);
207        }
208        len
209    }
210}
211
212#[derive(Debug, PartialEq, Eq, Clone)]
213pub struct Parameter {
214    parameter_id: ParameterId,
215    value: Vec<u8>,
216}
217
218impl Parameter {
219    pub fn new(parameter_id: ParameterId, value: Vec<u8>) -> Self {
220        Self {
221            parameter_id,
222            value,
223        }
224    }
225
226    pub fn parameter_id(&self) -> ParameterId {
227        self.parameter_id
228    }
229
230    pub fn value(&self) -> &[u8] {
231        self.value.as_ref()
232    }
233
234    pub fn length(&self) -> i16 {
235        self.value.len() as i16
236    }
237}
238
239#[derive(Debug, PartialEq, Eq)]
240pub struct ParameterList {
241    parameter: Vec<Parameter>,
242}
243
244impl ParameterList {
245    pub fn new(parameter: Vec<Parameter>) -> Self {
246        Self { parameter }
247    }
248
249    pub fn empty() -> Self {
250        Self { parameter: vec![] }
251    }
252
253    pub fn parameter(&self) -> &[Parameter] {
254        self.parameter.as_ref()
255    }
256}
257
258impl FromBytes for Parameter {
259    fn from_bytes<E: byteorder::ByteOrder>(v: &[u8]) -> Self {
260        let parameter_id = E::read_i16(&v[0..]);
261        let length = E::read_i16(&v[2..]);
262        let value = if parameter_id == PID_SENTINEL {
263            &[]
264        } else {
265            &v[4..length as usize + 4]
266        };
267
268        Self::new(parameter_id, value.to_vec())
269    }
270}
271
272impl FromBytes for ParameterList {
273    fn from_bytes<E: byteorder::ByteOrder>(mut v: &[u8]) -> Self {
274        const MAX_PARAMETERS: usize = 2_usize.pow(16);
275
276        let mut parameter = vec![];
277        for _ in 0..MAX_PARAMETERS {
278            let parameter_i = Parameter::from_bytes::<E>(v);
279            if parameter_i.parameter_id() == PID_SENTINEL {
280                break;
281            } else {
282                v.consume(parameter_i.length() as usize + 4);
283                parameter.push(parameter_i);
284            }
285        }
286        Self::new(parameter)
287    }
288}
289
290impl WriteBytes for Parameter {
291    fn write_bytes(&self, mut buf: &mut [u8]) -> usize {
292        let padding_len = match self.value().len() % 4 {
293            1 => 3,
294            2 => 2,
295            3 => 1,
296            _ => 0,
297        };
298        let length = self.value().len() + padding_len;
299        self.parameter_id().write_bytes(&mut buf[0..]);
300        (length as i16).write_bytes(&mut buf[2..]);
301        buf = &mut buf[4..];
302        buf[..self.value().len()].copy_from_slice(self.value().as_ref());
303        buf[self.value().len()..length].fill(0);
304        4 + length
305    }
306}
307
308impl WriteBytes for &ParameterList {
309    fn write_bytes(&self, buf: &mut [u8]) -> usize {
310        let mut length = 0;
311        for parameter in self.parameter().iter() {
312            length += parameter.write_bytes(&mut buf[length..]);
313        }
314        PID_SENTINEL.write_bytes(&mut buf[length..]);
315        buf[length + 2..length + 4].fill(0);
316        length + 4
317    }
318}
319
320#[derive(Debug, Eq, Clone)]
321pub struct ArcSlice {
322    data: Arc<[u8]>,
323    range: Range<usize>,
324}
325
326impl ArcSlice {
327    pub fn new(data: Arc<[u8]>, range: Range<usize>) -> Self {
328        Self { data, range }
329    }
330
331    pub fn len(&self) -> usize {
332        self.range.len()
333    }
334
335    pub fn is_empty(&self) -> bool {
336        self.range.len() == 0
337    }
338
339    pub fn as_slice(&self) -> &[u8] {
340        &self.data[self.range.clone()]
341    }
342
343    pub fn sub_slice(&self, range: RangeFrom<usize>) -> ArcSlice {
344        ArcSlice {
345            data: self.data.clone(),
346            range: range.start + self.range.start..self.range.end,
347        }
348    }
349}
350
351impl PartialEq for ArcSlice {
352    fn eq(&self, other: &Self) -> bool {
353        self.as_slice() == other.as_slice()
354    }
355}
356
357impl AsRef<[u8]> for ArcSlice {
358    fn as_ref(&self) -> &[u8] {
359        &self.data[self.range.clone()]
360    }
361}
362
363impl Index<Range<usize>> for ArcSlice {
364    type Output = [u8];
365    fn index(&self, index: Range<usize>) -> &Self::Output {
366        &self.data[self.range.clone()][index]
367    }
368}
369impl Index<RangeFrom<usize>> for ArcSlice {
370    type Output = [u8];
371    fn index(&self, index: RangeFrom<usize>) -> &Self::Output {
372        &self.data[self.range.clone()][index]
373    }
374}
375impl Index<RangeTo<usize>> for ArcSlice {
376    type Output = [u8];
377    fn index(&self, index: RangeTo<usize>) -> &Self::Output {
378        &self.data[self.range.clone()][index]
379    }
380}
381impl Index<usize> for ArcSlice {
382    type Output = u8;
383    fn index(&self, index: usize) -> &Self::Output {
384        &self.data[self.range.clone()][index]
385    }
386}
387
388impl From<Arc<[u8]>> for ArcSlice {
389    fn from(data: Arc<[u8]>) -> Self {
390        let range = 0..data.len();
391        Self { data, range }
392    }
393}
394
395impl From<Vec<u8>> for ArcSlice {
396    fn from(value: Vec<u8>) -> Self {
397        let range = 0..value.len();
398        Self {
399            data: value.into(),
400            range,
401        }
402    }
403}
404
405#[derive(Debug, PartialEq, Eq, Clone)]
406pub struct Data(ArcSlice);
407
408impl Data {
409    pub fn new(data: ArcSlice) -> Self {
410        Self(data)
411    }
412    pub fn len(&self) -> usize {
413        self.0.len()
414    }
415    pub fn is_empty(&self) -> bool {
416        self.0.len() == 0
417    }
418}
419
420impl AsRef<[u8]> for Data {
421    fn as_ref(&self) -> &[u8] {
422        self.0.as_slice()
423    }
424}
425
426impl WriteBytes for &Data {
427    #[inline]
428    fn write_bytes(&self, buf: &mut [u8]) -> usize {
429        buf[..self.0.len()].copy_from_slice(self.0.as_slice());
430        let length_inclusive_padding = (self.0.len() + 3) & !3;
431        buf[self.0.len()..length_inclusive_padding].fill(0);
432        length_inclusive_padding
433    }
434}
435
436impl FromBytes for EntityId {
437    fn from_bytes<E: byteorder::ByteOrder>(v: &[u8]) -> Self {
438        Self::new([v[0], v[1], v[2]], v[3])
439    }
440}
441
442impl FromBytes for GuidPrefix {
443    fn from_bytes<E: byteorder::ByteOrder>(v: &[u8]) -> Self {
444        [
445            v[0], v[1], v[2], v[3], v[4], v[5], v[6], v[7], v[8], v[9], v[10], v[11],
446        ]
447    }
448}
449
450impl FromBytes for SequenceNumber {
451    fn from_bytes<E: byteorder::ByteOrder>(v: &[u8]) -> Self {
452        let high = E::read_i32(&v[0..]);
453        let low = E::read_i32(&v[4..]);
454        let value = ((high as i64) << 32) + low as i64;
455        SequenceNumber::from(value)
456    }
457}
458
459impl FromBytes for Count {
460    fn from_bytes<E: byteorder::ByteOrder>(v: &[u8]) -> Self {
461        E::read_i32(v)
462    }
463}
464
465impl FromBytes for SequenceNumberSet {
466    fn from_bytes<E: byteorder::ByteOrder>(v: &[u8]) -> Self {
467        let high = E::read_i32(&v[0..]);
468        let low = E::read_i32(&v[4..]);
469        let base = SequenceNumber::from(((high as i64) << 32) + low as i64);
470
471        let num_bits = E::read_u32(&v[8..]);
472        let number_of_bitmap_elements = ((num_bits + 31) / 32) as usize; //In standard referred to as "M"
473        let mut bitmap = [0; 8];
474        let mut buf = &v[12..];
475        for bitmap_i in bitmap.iter_mut().take(number_of_bitmap_elements) {
476            *bitmap_i = E::read_i32(buf);
477            buf.consume(4);
478        }
479
480        SequenceNumberSet {
481            base,
482            num_bits,
483            bitmap,
484        }
485    }
486}
487
488impl FromBytes for u16 {
489    fn from_bytes<E: byteorder::ByteOrder>(v: &[u8]) -> Self {
490        E::read_u16(v)
491    }
492}
493
494impl FromBytes for i16 {
495    fn from_bytes<E: byteorder::ByteOrder>(v: &[u8]) -> Self {
496        E::read_i16(v)
497    }
498}
499
500impl FromBytes for u32 {
501    fn from_bytes<E: byteorder::ByteOrder>(v: &[u8]) -> Self {
502        E::read_u32(v)
503    }
504}
505
506impl FromBytes for Locator {
507    fn from_bytes<E: byteorder::ByteOrder>(v: &[u8]) -> Self {
508        let kind = E::read_i32(&v[0..]);
509        let port = E::read_u32(&v[4..]);
510        let address = [
511            v[8], v[9], v[10], v[11], v[12], v[13], v[14], v[15], v[16], v[17], v[18], v[19],
512            v[20], v[21], v[22], v[23],
513        ];
514        Self::new(kind, port, address)
515    }
516}
517
518impl FromBytes for LocatorList {
519    fn from_bytes<E: byteorder::ByteOrder>(v: &[u8]) -> Self {
520        let num_locators = E::read_u32(v);
521        let mut buf = &v[4..];
522        let mut locator_list = Vec::new();
523        for _ in 0..num_locators {
524            locator_list.push(Locator::from_bytes::<E>(buf));
525            buf.consume(24)
526        }
527        Self::new(locator_list)
528    }
529}
530
531impl FromBytes for ProtocolVersion {
532    fn from_bytes<E: byteorder::ByteOrder>(v: &[u8]) -> Self {
533        Self::new(v[0], v[1])
534    }
535}
536
537impl FromBytes for VendorId {
538    fn from_bytes<E: byteorder::ByteOrder>(v: &[u8]) -> Self {
539        [v[0], v[1]]
540    }
541}
542
543impl FromBytes for Time {
544    fn from_bytes<E: byteorder::ByteOrder>(v: &[u8]) -> Self {
545        let seconds = E::read_u32(&v[0..]);
546        let fractions = E::read_u32(&v[4..]);
547        Self::new(seconds, fractions)
548    }
549}
550
551impl FromBytes for FragmentNumberSet {
552    fn from_bytes<E: byteorder::ByteOrder>(v: &[u8]) -> Self {
553        let base = E::read_u32(&v[0..]);
554        let num_bits = E::read_u32(&v[4..]);
555        let number_of_bitmap_elements = ((num_bits + 31) / 32) as usize; //In standard referred to as "M"
556        let mut bitmap = [0; 8];
557        let mut buf = &v[8..];
558        for bitmap_i in bitmap.iter_mut().take(number_of_bitmap_elements) {
559            *bitmap_i = E::read_i32(buf);
560            buf.consume(4);
561        }
562
563        let mut set = Vec::with_capacity(256);
564        for delta_n in 0..num_bits as usize {
565            if (bitmap[delta_n / 32] & (1 << (31 - delta_n % 32))) == (1 << (31 - delta_n % 32)) {
566                set.push(base + delta_n as u32);
567            }
568        }
569        Self::new(base, set)
570    }
571}
572
573#[cfg(test)]
574mod tests {
575    use super::*;
576    use crate::rtps::{
577        messages::overall_structure::into_bytes_vec, types::Locator,
578    };
579
580    #[test]
581    fn sequence_number_set_methods() {
582        let base = SequenceNumber::from(100);
583        let set = [
584            SequenceNumber::from(102),
585            SequenceNumber::from(200),
586            SequenceNumber::from(355),
587        ];
588        let seq_num_set = SequenceNumberSet::new(base, set);
589
590        assert_eq!(seq_num_set.base(), base);
591        assert!(
592            seq_num_set.set().eq(set),
593            "{:?} not equal to {:?}",
594            seq_num_set.set().collect::<Vec<_>>(),
595            set
596        );
597    }
598
599    #[test]
600    fn serialize_fragment_number_max_gap() {
601        let fragment_number_set = FragmentNumberSet {
602            base: 2,
603            set: vec![2, 257],
604        };
605        #[rustfmt::skip]
606        assert_eq!(into_bytes_vec(fragment_number_set), vec![
607            2, 0, 0, 0, // bitmapBase: (unsigned long)
608            0, 1, 0, 0, // numBits (unsigned long)
609            0b000_0000, 0b_0000_0000, 0b_0000_0000, 0b_1000_0000, // bitmap[0] (long)
610            0b000_0000, 0b_0000_0000, 0b_0000_0000, 0b_0000_0000, // bitmap[1] (long)
611            0b000_0000, 0b_0000_0000, 0b_0000_0000, 0b_0000_0000, // bitmap[2] (long)
612            0b000_0000, 0b_0000_0000, 0b_0000_0000, 0b_0000_0000, // bitmap[3] (long)
613            0b000_0000, 0b_0000_0000, 0b_0000_0000, 0b_0000_0000, // bitmap[4] (long)
614            0b000_0000, 0b_0000_0000, 0b_0000_0000, 0b_0000_0000, // bitmap[5] (long)
615            0b000_0000, 0b_0000_0000, 0b_0000_0000, 0b_0000_0000, // bitmap[6] (long)
616            0b000_0001, 0b_0000_0000, 0b_0000_0000, 0b_0000_0000, // bitmap[7] (long)
617        ]);
618    }
619
620    #[test]
621    fn serialize_locator_list() {
622        let locator_1 = Locator::new(1, 2, [3; 16]);
623        let locator_2 = Locator::new(2, 2, [3; 16]);
624        let locator_list = LocatorList::new(vec![locator_1, locator_2]);
625        assert_eq!(
626            into_bytes_vec(locator_list),
627            vec![
628                2, 0, 0, 0, // numLocators (unsigned long)
629                1, 0, 0, 0, // kind (long)
630                2, 0, 0, 0, // port (unsigned long)
631                3, 3, 3, 3, // address (octet[16])
632                3, 3, 3, 3, // address (octet[16])
633                3, 3, 3, 3, // address (octet[16])
634                3, 3, 3, 3, // address (octet[16])
635                2, 0, 0, 0, // kind (long)
636                2, 0, 0, 0, // port (unsigned long)
637                3, 3, 3, 3, // address (octet[16])
638                3, 3, 3, 3, // address (octet[16])
639                3, 3, 3, 3, // address (octet[16])
640                3, 3, 3, 3, // address (octet[16])
641            ]
642        );
643    }
644
645    #[test]
646    fn deserialize_count() {
647        let expected = 7;
648        assert_eq!(
649            expected,
650            Count::from_bytes::<byteorder::LittleEndian>(&[
651            7, 0, 0,0 , //value (long)
652        ])
653        );
654    }
655
656    #[test]
657    fn deserialize_locator_list() {
658        let locator_1 = Locator::new(1, 2, [3; 16]);
659        let locator_2 = Locator::new(2, 2, [3; 16]);
660        let expected = LocatorList::new(vec![locator_1, locator_2]);
661        #[rustfmt::skip]
662        let result = LocatorList::from_bytes::<byteorder::LittleEndian>(&[
663            2, 0, 0, 0,  // numLocators (unsigned long)
664            1, 0, 0, 0, // kind (long)
665            2, 0, 0, 0, // port (unsigned long)
666            3, 3, 3, 3, // address (octet[16])
667            3, 3, 3, 3, // address (octet[16])
668            3, 3, 3, 3, // address (octet[16])
669            3, 3, 3, 3, // address (octet[16])
670            2, 0, 0, 0, // kind (long)
671            2, 0, 0, 0, // port (unsigned long)
672            3, 3, 3, 3, // address (octet[16])
673            3, 3, 3, 3, // address (octet[16])
674            3, 3, 3, 3, // address (octet[16])
675            3, 3, 3, 3, // address (octet[16])
676
677        ]);
678        assert_eq!(expected, result);
679    }
680
681    #[test]
682    fn deserialize_fragment_number() {
683        let expected = 7;
684        assert_eq!(
685            expected,
686            FragmentNumber::from_bytes::<byteorder::LittleEndian>(&[
687                7, 0, 0, 0, // (unsigned long)
688            ])
689        );
690    }
691
692    #[test]
693    fn deserialize_fragment_number_set_max_gap() {
694        let expected = FragmentNumberSet {
695            base: 2,
696            set: vec![2, 257],
697        };
698        #[rustfmt::skip]
699        let result = FragmentNumberSet::from_bytes::<byteorder::LittleEndian>(&[
700            2, 0, 0, 0, // bitmapBase: (unsigned long)
701            0, 1, 0, 0, // numBits (unsigned long)
702            0b000_0000, 0b_0000_0000, 0b_0000_0000, 0b_1000_0000, // bitmap[0] (long)
703            0b000_0000, 0b_0000_0000, 0b_0000_0000, 0b_0000_0000, // bitmap[1] (long)
704            0b000_0000, 0b_0000_0000, 0b_0000_0000, 0b_0000_0000, // bitmap[2] (long)
705            0b000_0000, 0b_0000_0000, 0b_0000_0000, 0b_0000_0000, // bitmap[3] (long)
706            0b000_0000, 0b_0000_0000, 0b_0000_0000, 0b_0000_0000, // bitmap[4] (long)
707            0b000_0000, 0b_0000_0000, 0b_0000_0000, 0b_0000_0000, // bitmap[5] (long)
708            0b000_0000, 0b_0000_0000, 0b_0000_0000, 0b_0000_0000, // bitmap[6] (long)
709            0b000_0001, 0b_0000_0000, 0b_0000_0000, 0b_0000_0000, // bitmap[7] (long)
710
711        ]);
712        assert_eq!(expected, result);
713    }
714
715    #[test]
716    fn deserialize_guid_prefix() {
717        let expected = [1; 12];
718        #[rustfmt::skip]
719        assert_eq!(expected, GuidPrefix::from_bytes::<byteorder::LittleEndian>(&[
720            1, 1, 1, 1,
721            1, 1, 1, 1,
722            1, 1, 1, 1,
723        ]));
724    }
725
726    #[test]
727    fn deserialize_protocol_version() {
728        let expected = ProtocolVersion::new(2, 3);
729        assert_eq!(
730            expected,
731            ProtocolVersion::from_bytes::<byteorder::LittleEndian>(&[2, 3])
732        );
733    }
734
735    #[test]
736    fn deserialize_vendor_id() {
737        let expected = [1, 2];
738        assert_eq!(
739            expected,
740            VendorId::from_bytes::<byteorder::LittleEndian>(&[1, 2,])
741        );
742    }
743
744    #[test]
745    fn deserialize_sequence_number() {
746        let expected = SequenceNumber::from(7);
747        assert_eq!(
748            expected,
749            SequenceNumber::from_bytes::<byteorder::LittleEndian>(&[
750                0, 0, 0, 0, // high (long)
751                7, 0, 0, 0, // low (unsigned long)
752            ])
753        );
754    }
755
756    #[test]
757    fn serialize_sequence_number_max_gap() {
758        let sequence_number_set = SequenceNumberSet::new(
759            SequenceNumber::from(2),
760            [SequenceNumber::from(2), SequenceNumber::from(257)],
761        );
762        #[rustfmt::skip]
763        assert_eq!(into_bytes_vec(sequence_number_set), vec![
764            0, 0, 0, 0, // bitmapBase: high (long)
765            2, 0, 0, 0, // bitmapBase: low (unsigned long)
766            0, 1, 0, 0, // numBits (unsigned long)
767            0b000_0000, 0b_0000_0000, 0b_0000_0000, 0b_1000_0000, // bitmap[0] (long)
768            0b000_0000, 0b_0000_0000, 0b_0000_0000, 0b_0000_0000, // bitmap[1] (long)
769            0b000_0000, 0b_0000_0000, 0b_0000_0000, 0b_0000_0000, // bitmap[2] (long)
770            0b000_0000, 0b_0000_0000, 0b_0000_0000, 0b_0000_0000, // bitmap[3] (long)
771            0b000_0000, 0b_0000_0000, 0b_0000_0000, 0b_0000_0000, // bitmap[4] (long)
772            0b000_0000, 0b_0000_0000, 0b_0000_0000, 0b_0000_0000, // bitmap[5] (long)
773            0b000_0000, 0b_0000_0000, 0b_0000_0000, 0b_0000_0000, // bitmap[6] (long)
774            0b000_0001, 0b_0000_0000, 0b_0000_0000, 0b_0000_0000, // bitmap[7] (long)
775        ]);
776    }
777
778    #[test]
779    fn deserialize_sequence_number_set_max_gap() {
780        let expected = SequenceNumberSet::new(
781            SequenceNumber::from(2),
782            [SequenceNumber::from(2), SequenceNumber::from(257)],
783        );
784        #[rustfmt::skip]
785        let result = SequenceNumberSet::from_bytes::<byteorder::LittleEndian>(&[
786            0, 0, 0, 0, // bitmapBase: high (long)
787            2, 0, 0, 0, // bitmapBase: low (unsigned long)
788            0, 1, 0, 0, // numBits (unsigned long)
789            0b000_0000, 0b_0000_0000, 0b_0000_0000, 0b_1000_0000, // bitmap[0] (long)
790            0b000_0000, 0b_0000_0000, 0b_0000_0000, 0b_0000_0000, // bitmap[1] (long)
791            0b000_0000, 0b_0000_0000, 0b_0000_0000, 0b_0000_0000, // bitmap[2] (long)
792            0b000_0000, 0b_0000_0000, 0b_0000_0000, 0b_0000_0000, // bitmap[3] (long)
793            0b000_0000, 0b_0000_0000, 0b_0000_0000, 0b_0000_0000, // bitmap[4] (long)
794            0b000_0000, 0b_0000_0000, 0b_0000_0000, 0b_0000_0000, // bitmap[5] (long)
795            0b000_0000, 0b_0000_0000, 0b_0000_0000, 0b_0000_0000, // bitmap[6] (long)
796            0b000_0001, 0b_0000_0000, 0b_0000_0000, 0b_0000_0000, // bitmap[7] (long)
797        ]);
798        assert_eq!(expected, result);
799    }
800
801    #[test]
802    fn serialize_parameter() {
803        let parameter = Parameter::new(2, vec![5, 6, 7, 8]);
804        #[rustfmt::skip]
805        assert_eq!(into_bytes_vec(parameter), vec![
806            0x02, 0x00, 4, 0, // Parameter | length
807            5, 6, 7, 8,       // value
808        ]);
809    }
810
811    #[test]
812    fn serialize_parameter_non_multiple_4() {
813        let parameter = Parameter::new(2, vec![5, 6, 7]);
814        #[rustfmt::skip]
815        assert_eq!(into_bytes_vec(parameter), vec![
816            0x02, 0x00, 4, 0, // Parameter | length
817            5, 6, 7, 0,       // value
818        ]);
819    }
820
821    #[test]
822    fn serialize_parameter_zero_size() {
823        let parameter = Parameter::new(2, vec![]);
824        assert_eq!(
825            into_bytes_vec(parameter),
826            vec![
827            0x02, 0x00, 0, 0, // Parameter | length
828        ]
829        );
830    }
831
832    #[test]
833    fn serialize_parameter_list() {
834        let parameter_1 = Parameter::new(2, vec![51, 61, 71, 81]);
835        let parameter_2 = Parameter::new(3, vec![52, 62, 0, 0]);
836        let parameter_list_submessage_element = &ParameterList::new(vec![parameter_1, parameter_2]);
837        #[rustfmt::skip]
838        assert_eq!(into_bytes_vec(parameter_list_submessage_element), vec![
839            0x02, 0x00, 4, 0, // Parameter ID | length
840            51, 61, 71, 81,   // value
841            0x03, 0x00, 4, 0, // Parameter ID | length
842            52, 62, 0, 0,   // value
843            0x01, 0x00, 0, 0, // Sentinel: PID_SENTINEL | PID_PAD
844        ]);
845    }
846
847    #[test]
848    fn serialize_parameter_list_empty() {
849        let parameter = &ParameterList::empty();
850        #[rustfmt::skip]
851        assert_eq!(into_bytes_vec(parameter), vec![
852            0x01, 0x00, 0, 0, // Sentinel: PID_SENTINEL | PID_PAD
853        ]);
854    }
855
856    #[test]
857    fn deserialize_parameter_non_multiple_of_4() {
858        let expected = Parameter::new(2, vec![5, 6, 7, 8, 9, 10, 11, 0]);
859        #[rustfmt::skip]
860        let result = Parameter::from_bytes::<byteorder::LittleEndian>(&[
861            0x02, 0x00, 8, 0, // Parameter | length
862            5, 6, 7, 8,       // value
863            9, 10, 11, 0,     // value
864        ]);
865        assert_eq!(expected, result);
866    }
867
868    #[test]
869    fn deserialize_parameter() {
870        let expected = Parameter::new(2, vec![5, 6, 7, 8, 9, 10, 11, 12]);
871        #[rustfmt::skip]
872        let result = Parameter::from_bytes::<byteorder::LittleEndian>(&[
873            0x02, 0x00, 8, 0, // Parameter | length
874            5, 6, 7, 8,       // value
875            9, 10, 11, 12,       // value
876        ]);
877        assert_eq!(expected, result);
878    }
879
880    #[test]
881    fn deserialize_parameter_list() {
882        let expected = ParameterList::new(vec![
883            Parameter::new(2, vec![15, 16, 17, 18]),
884            Parameter::new(3, vec![25, 26, 27, 28]),
885        ]);
886        #[rustfmt::skip]
887        let result = ParameterList::from_bytes::<byteorder::LittleEndian>(&[
888            0x02, 0x00, 4, 0, // Parameter ID | length
889            15, 16, 17, 18,        // value
890            0x03, 0x00, 4, 0, // Parameter ID | length
891            25, 26, 27, 28,        // value
892            0x01, 0x00, 0, 0, // Sentinel: Parameter ID | length
893        ]);
894        assert_eq!(expected, result);
895    }
896
897    #[test]
898    fn deserialize_parameter_list_with_long_parameter_including_sentinel() {
899        #[rustfmt::skip]
900        let parameter_value_expected = vec![
901            0x01, 0x00, 0x00, 0x00,
902            0x01, 0x00, 0x00, 0x00,
903            0x01, 0x01, 0x01, 0x01,
904            0x01, 0x01, 0x01, 0x01,
905            0x01, 0x01, 0x01, 0x01,
906            0x01, 0x01, 0x01, 0x01,
907        ];
908
909        let expected = ParameterList::new(vec![Parameter::new(0x32, parameter_value_expected)]);
910        #[rustfmt::skip]
911        let result = ParameterList::from_bytes::<byteorder::LittleEndian>(&[
912            0x32, 0x00, 24, 0x00, // Parameter ID | length
913            0x01, 0x00, 0x00, 0x00, // Parameter value
914            0x01, 0x00, 0x00, 0x00, // Parameter value
915            0x01, 0x01, 0x01, 0x01, // Parameter value
916            0x01, 0x01, 0x01, 0x01, // Parameter value
917            0x01, 0x01, 0x01, 0x01, // Parameter value
918            0x01, 0x01, 0x01, 0x01, // Parameter value
919            0x01, 0x00, 0x00, 0x00, // PID_SENTINEL, Length: 0
920        ]);
921        assert_eq!(expected, result);
922    }
923
924    #[test]
925    fn deserialize_parameter_list_with_multiple_parameters_with_same_id() {
926        #[rustfmt::skip]
927        let parameter_value_expected1 = vec![
928            0x01, 0x00, 0x00, 0x00,
929            0x01, 0x00, 0x00, 0x00,
930            0x01, 0x01, 0x01, 0x01,
931            0x01, 0x01, 0x01, 0x01,
932            0x01, 0x01, 0x01, 0x01,
933            0x01, 0x01, 0x01, 0x01,
934        ];
935        #[rustfmt::skip]
936        let parameter_value_expected2 = vec![
937            0x01, 0x00, 0x00, 0x00,
938            0x01, 0x00, 0x00, 0x00,
939            0x02, 0x02, 0x02, 0x02,
940            0x02, 0x02, 0x02, 0x02,
941            0x02, 0x02, 0x02, 0x02,
942            0x02, 0x02, 0x02, 0x02,
943        ];
944
945        let expected = ParameterList::new(vec![
946            Parameter::new(0x32, parameter_value_expected1),
947            Parameter::new(0x32, parameter_value_expected2),
948        ]);
949        #[rustfmt::skip]
950        let result = ParameterList::from_bytes::<byteorder::LittleEndian>(&[
951            0x32, 0x00, 24, 0x00, // Parameter ID | length
952            0x01, 0x00, 0x00, 0x00, // Parameter value
953            0x01, 0x00, 0x00, 0x00, // Parameter value
954            0x01, 0x01, 0x01, 0x01, // Parameter value
955            0x01, 0x01, 0x01, 0x01, // Parameter value
956            0x01, 0x01, 0x01, 0x01, // Parameter value
957            0x01, 0x01, 0x01, 0x01, // Parameter value
958            0x32, 0x00, 24, 0x00, // Parameter ID | length
959            0x01, 0x00, 0x00, 0x00, // Parameter value
960            0x01, 0x00, 0x00, 0x00, // Parameter value
961            0x02, 0x02, 0x02, 0x02, // Parameter value
962            0x02, 0x02, 0x02, 0x02, // Parameter value
963            0x02, 0x02, 0x02, 0x02, // Parameter value
964            0x02, 0x02, 0x02, 0x02, // Parameter value
965            0x01, 0x00, 0x00, 0x00, // PID_SENTINEL, Length: 0
966        ]);
967        assert_eq!(expected, result);
968    }
969}
rtps_parser/rtps/messages/submessage_elements.rs

rtps_parser/rtps/messages/
submessage_elements.rs
