rtps-rs 0.1.2

Real Time Publish Subscribe protocol
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

use num_derive::{FromPrimitive, NumOps, ToPrimitive};
use speedy::{Context, Readable, Reader, Writable, Writer};
use std::convert::From;
use std::mem::size_of;

#[derive(
    Copy, Clone, Debug, Hash, PartialEq, Eq, PartialOrd, Ord, NumOps, FromPrimitive, ToPrimitive,
)]
pub struct SequenceNumber_t(i64);

impl SequenceNumber_t {
    pub const SEQUENCENUMBER_UNKNOWN: SequenceNumber_t =
        SequenceNumber_t((std::u32::MAX as i64) << 32);
}

impl From<i64> for SequenceNumber_t {
    fn from(value: i64) -> Self {
        SequenceNumber_t(value)
    }
}

impl From<SequenceNumber_t> for i64 {
    fn from(sequence_number: SequenceNumber_t) -> Self {
        sequence_number.0
    }
}

checked_impl!(CheckedAdd, checked_add, SequenceNumber_t);
checked_impl!(CheckedSub, checked_sub, SequenceNumber_t);
checked_impl!(CheckedMul, checked_mul, SequenceNumber_t);
checked_impl!(CheckedDiv, checked_div, SequenceNumber_t);

impl<'a, C: Context> Readable<'a, C> for SequenceNumber_t {
    #[inline]
    fn read_from<R: Reader<'a, C>>(reader: &mut R) -> Result<Self, C::Error> {
        let high: i32 = reader.read_value()?;
        let low: u32 = reader.read_value()?;

        Ok(SequenceNumber_t(((i64::from(high)) << 32) + i64::from(low)))
    }

    #[inline]
    fn minimum_bytes_needed() -> usize {
        size_of::<Self>()
    }
}

impl<C: Context> Writable<C> for SequenceNumber_t {
    #[inline]
    fn write_to<T: ?Sized + Writer<C>>(&self, writer: &mut T) -> Result<(), C::Error> {
        writer.write_i32((self.0 >> 32) as i32)?;
        writer.write_u32(self.0 as u32)?;
        Ok(())
    }
}

impl Default for SequenceNumber_t {
    fn default() -> SequenceNumber_t {
        SequenceNumber_t(1)
    }
}

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

    #[test]
    fn sequence_number_starts_by_default_from_one() {
        assert_eq!(SequenceNumber_t::from(1), SequenceNumber_t::default());
    }

    serialization_test!( type = SequenceNumber_t,
    {
        sequence_number_default,
        SequenceNumber_t::default(),
        le = [0x00, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00],
        be = [0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x01]
    },
    {
        sequence_number_unknown,
        SequenceNumber_t::SEQUENCENUMBER_UNKNOWN,
        le = [0xFF, 0xFF, 0xFF, 0xFF, 0x00, 0x00, 0x00, 0x00],
        be = [0xFF, 0xFF, 0xFF, 0xFF, 0x00, 0x00, 0x00, 0x00]
    },
    {
        sequence_number_non_zero,
        SequenceNumber_t::from(0x0011223344556677),
        le = [0x33, 0x22, 0x11, 0x00, 0x77, 0x66, 0x55, 0x44],
        be = [0x00, 0x11, 0x22, 0x33, 0x44, 0x55, 0x66, 0x77]
    });
}