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
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121

use crate::structure::parameter_id::ParameterId;
use speedy::{Context, Readable, Reader, Writable, Writer};

#[derive(Debug, PartialEq)]
pub struct Parameter {
    /// Uniquely identifies the type of parameter
    parameter_id: ParameterId,
    /// Contains the CDR encapsulation of the Parameter type
    /// that corresponds to the specified parameterId
    value: Vec<u8>,
}

impl<'a, C: Context> Readable<'a, C> for Parameter {
    #[inline]
    fn read_from<R: Reader<'a, C>>(reader: &mut R) -> Result<Self, C::Error> {
        let parameter_id: ParameterId = reader.read_value()?;
        let length = reader.read_u16()?;
        let alignment = length % 4;

        let mut value = Vec::with_capacity((length + alignment) as usize);

        for _ in 0..(length + alignment) {
            let byte = reader.read_u8()?;
            value.push(byte);
        }

        Ok(Parameter {
            parameter_id: parameter_id,
            value: value,
        })
    }

    #[inline]
    fn minimum_bytes_needed() -> usize {
        8
    }
}

impl<C: Context> Writable<C> for Parameter {
    #[inline]
    fn write_to<T: ?Sized + Writer<C>>(&self, writer: &mut T) -> Result<(), C::Error> {
        writer.write_value(&self.parameter_id)?;

        let length = self.value.len();
        let alignment = length % 4;
        writer.write_u16((length + alignment) as u16)?;

        for byte in &self.value {
            writer.write_u8(*byte)?;
        }

        for _ in 0..alignment {
            writer.write_u8(0x00)?;
        }

        Ok(())
    }
}

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

    serialization_test!( type = Parameter,
    {
        pid_protocol_version,
        Parameter {
            parameter_id: ParameterId::PID_PROTOCOL_VERSION,
            value: vec![0x02, 0x01, 0x00, 0x00],
        },
        le = [0x15, 0x00, 0x04, 0x00,
              0x02, 0x01, 0x00, 0x00],
        be = [0x00, 0x15, 0x00, 0x04,
              0x02, 0x01, 0x00, 0x00]
    },
    {
        pid_vendor_id,
        Parameter {
            parameter_id: ParameterId::PID_VENDOR_ID,
            value: vec![0x01, 0x02, 0x03, 0x04],
        },
        le = [0x16, 0x00, 0x04, 0x00,
              0x01, 0x02, 0x03, 0x04],
        be = [0x00, 0x16, 0x00, 0x04,
              0x01, 0x02, 0x03, 0x04]
    },
    {
        pid_participant_guid,
        Parameter {
            parameter_id: ParameterId::PID_PARTICIPANT_GUID,
            value: vec![0x01, 0x0F, 0xBB, 0x1D,
                        0xDF, 0x2B, 0x00, 0x00,
                        0x00, 0x00, 0x00, 0x00,
                        0x00, 0x00, 0x01, 0xC1],
        },
        le = [0x50, 0x00, 0x10, 0x00,
              0x01, 0x0F, 0xBB, 0x1D,
              0xDF, 0x2B, 0x00, 0x00,
              0x00, 0x00, 0x00, 0x00,
              0x00, 0x00, 0x01, 0xC1],
        be = [0x00, 0x50, 0x00, 0x10,
              0x01, 0x0F, 0xBB, 0x1D,
              0xDF, 0x2B, 0x00, 0x00,
              0x00, 0x00, 0x00, 0x00,
              0x00, 0x00, 0x01, 0xC1]
    },
    {
        pid_participant_lease_duration,
        Parameter {
            parameter_id: ParameterId::PID_PARTICIPANT_LEASE_DURATION,
            value: vec![0xFF, 0xFF, 0xFF, 0x7F,
                        0xFF, 0xFF, 0xFF, 0xFF],
        },
        le = [0x02, 0x00, 0x08, 0x00,
              0xFF, 0xFF, 0xFF, 0x7F,
              0xFF, 0xFF, 0xFF, 0xFF],
        be = [0x00, 0x02, 0x00, 0x08,
              0xFF, 0xFF, 0xFF, 0x7F,
              0xFF, 0xFF, 0xFF, 0xFF]
    });
}