hiroz 0.2.0

Native Rust ROS 2 implementation using Zenoh
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

use zenoh::bytes::ZBytes;
use zenoh_ext::{ZDeserializer, ZSerializer};

use crate::time::{ZClock, ZTime};

const RMW_GID_STORAGE_SIZE: usize = 16;

pub type GidArray = [u8; RMW_GID_STORAGE_SIZE];

#[derive(Clone, Hash)]
pub struct Attachment {
    pub sequence_number: i64,
    pub source_timestamp: i64,
    pub source_gid: GidArray,
}

impl Attachment {
    pub fn new(sn: i64, gid: GidArray) -> Self {
        Self::with_source_time(
            sn,
            gid,
            ZTime::from_system_time(std::time::SystemTime::now()),
        )
    }

    pub fn with_clock(sn: i64, gid: GidArray, clock: &ZClock) -> Self {
        Self::with_source_time(sn, gid, clock.now())
    }

    pub fn with_source_time(sn: i64, gid: GidArray, source_time: ZTime) -> Self {
        Self {
            sequence_number: sn,
            source_timestamp: source_time.as_unix_nanos(),
            source_gid: gid,
        }
    }

    pub fn source_time(&self) -> ZTime {
        ZTime::from_unix_nanos(self.source_timestamp)
    }
}

impl TryFrom<&ZBytes> for Attachment {
    type Error = zenoh::Error;
    fn try_from(value: &ZBytes) -> Result<Self, Self::Error> {
        let mut des = ZDeserializer::new(value);
        let sequence_number = des.deserialize::<i64>()?;
        let source_timestamp = des.deserialize::<i64>()?;
        let source_gid = des.deserialize::<GidArray>()?;
        Ok(Attachment {
            sequence_number,
            source_timestamp,
            source_gid,
        })
    }
}

impl From<Attachment> for ZBytes {
    fn from(value: Attachment) -> Self {
        let mut ser = ZSerializer::new();
        ser.serialize(value.sequence_number);
        ser.serialize(value.source_timestamp);
        ser.serialize(value.source_gid);
        ser.finish()
    }
}