oxictl 0.1.1

Pure Rust Real-Time Control Systems Framework
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

use crate::protocol::dds::byte_cursor::{ByteCursor, ByteWriter, Endianness};
use crate::protocol::dds::error::RtpsError;
use crate::protocol::dds::message::RTPS_MAGIC;
use crate::protocol::dds::types::guid::{GuidPrefix, ProtocolVersion, VendorId};

/// RTPS message header (20 bytes): [RTPS magic 4][version 2][vendorId 2][guidPrefix 12].
///
/// The header fields are byte arrays; endianness is moot for magic/version/vendorId.
/// GuidPrefix is also a raw byte array, so no byte-order conversion is needed.
#[derive(Debug, Clone, PartialEq, Eq)]
pub struct MessageHeader {
    pub version: ProtocolVersion,
    pub vendor_id: VendorId,
    pub guid_prefix: GuidPrefix,
}

impl MessageHeader {
    /// Parse a 20-byte RTPS header. Returns `(header, remaining_bytes)`.
    pub fn parse(bytes: &[u8]) -> Result<(Self, &[u8]), RtpsError> {
        if bytes.len() < 20 {
            return Err(RtpsError::TruncatedHeader);
        }
        if bytes[0..4] != RTPS_MAGIC {
            return Err(RtpsError::InvalidMagic);
        }
        // version and vendorId are NOT endianness-sensitive (byte sequences).
        // Use Big endian cursor (moot; read_u8 / read_bytes are endian-independent).
        let mut cur = ByteCursor::new(&bytes[4..20], Endianness::Big);
        let version = ProtocolVersion::parse(&mut cur)?;
        if !version.is_compatible_2x() {
            return Err(RtpsError::UnsupportedVersion);
        }
        let vendor_id = VendorId::parse(&mut cur)?;
        let guid_prefix = GuidPrefix::parse(&mut cur)?;
        Ok((
            Self {
                version,
                vendor_id,
                guid_prefix,
            },
            &bytes[20..],
        ))
    }

    /// Serialize into `buf`. Returns bytes written (always 20 on success).
    pub fn serialize(&self, buf: &mut [u8]) -> Result<usize, RtpsError> {
        if buf.len() < 20 {
            return Err(RtpsError::BufferTooSmall);
        }
        buf[0..4].copy_from_slice(&RTPS_MAGIC);
        let mut w = ByteWriter::new(&mut buf[4..20], Endianness::Big);
        self.version.serialize(&mut w)?;
        self.vendor_id.serialize(&mut w)?;
        self.guid_prefix.serialize(&mut w)?;
        Ok(20)
    }
}