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
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
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151

//! C-compatible QoS types for FFI

use crate::qos::{
    QosDurability, QosDuration, QosHistory, QosLiveliness, QosProfile, QosReliability,
};
use std::num::NonZeroUsize;

/// C-compatible QoS profile for FFI
#[repr(C)]
pub struct CQosProfile {
    /// 0 = Reliable (default), 1 = BestEffort
    pub reliability: i32,
    /// 0 = Volatile (default), 1 = TransientLocal
    pub durability: i32,
    /// 0 = KeepLast (default), 1 = KeepAll
    pub history: i32,
    /// Depth for KeepLast (default: 10, ignored for KeepAll)
    pub history_depth: i32,
    pub deadline_sec: u64,
    pub deadline_nsec: u64,
    pub lifespan_sec: u64,
    pub lifespan_nsec: u64,
    /// 0 = Automatic (default), 1 = ManualByNode, 2 = ManualByTopic
    pub liveliness: i32,
    pub liveliness_lease_sec: u64,
    pub liveliness_lease_nsec: u64,
}

impl CQosProfile {
    /// Convert a nullable pointer to an optional QosProfile
    ///
    /// # Safety
    /// Pointer must be valid or null.
    pub unsafe fn to_qos_profile(ptr: *const CQosProfile) -> Option<QosProfile> {
        if ptr.is_null() {
            return None;
        }
        Some(unsafe { (*ptr).as_qos_profile() })
    }

    fn as_qos_profile(&self) -> QosProfile {
        let reliability = match self.reliability {
            1 => QosReliability::BestEffort,
            _ => QosReliability::Reliable,
        };

        let durability = match self.durability {
            1 => QosDurability::TransientLocal,
            _ => QosDurability::Volatile,
        };

        let history = match self.history {
            1 => QosHistory::KeepAll,
            _ => {
                let depth = if self.history_depth <= 0 {
                    crate::qos::DEFAULT_HISTORY_DEPTH
                } else {
                    self.history_depth as usize
                };
                QosHistory::KeepLast(
                    NonZeroUsize::new(depth)
                        .unwrap_or(NonZeroUsize::new(crate::qos::DEFAULT_HISTORY_DEPTH).unwrap()),
                )
            }
        };

        let deadline = QosDuration {
            sec: self.deadline_sec,
            nsec: self.deadline_nsec,
        };

        let lifespan = QosDuration {
            sec: self.lifespan_sec,
            nsec: self.lifespan_nsec,
        };

        let liveliness = match self.liveliness {
            1 => QosLiveliness::ManualByNode,
            2 => QosLiveliness::ManualByTopic,
            _ => QosLiveliness::Automatic,
        };

        let liveliness_lease_duration = QosDuration {
            sec: self.liveliness_lease_sec,
            nsec: self.liveliness_lease_nsec,
        };

        QosProfile {
            reliability,
            durability,
            history,
            deadline,
            lifespan,
            liveliness,
            liveliness_lease_duration,
        }
    }
}

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

    #[test]
    fn test_default_qos() {
        let c_qos = CQosProfile {
            reliability: 0,
            durability: 0,
            history: 0,
            history_depth: 10,
            deadline_sec: QosDuration::INFINITE.sec,
            deadline_nsec: QosDuration::INFINITE.nsec,
            lifespan_sec: QosDuration::INFINITE.sec,
            lifespan_nsec: QosDuration::INFINITE.nsec,
            liveliness: 0,
            liveliness_lease_sec: QosDuration::INFINITE.sec,
            liveliness_lease_nsec: QosDuration::INFINITE.nsec,
        };

        let qos = c_qos.as_qos_profile();
        assert_eq!(qos, QosProfile::default());
    }

    #[test]
    fn test_best_effort_transient_local() {
        let c_qos = CQosProfile {
            reliability: 1,
            durability: 1,
            history: 1,
            history_depth: 0,
            deadline_sec: QosDuration::INFINITE.sec,
            deadline_nsec: QosDuration::INFINITE.nsec,
            lifespan_sec: QosDuration::INFINITE.sec,
            lifespan_nsec: QosDuration::INFINITE.nsec,
            liveliness: 0,
            liveliness_lease_sec: QosDuration::INFINITE.sec,
            liveliness_lease_nsec: QosDuration::INFINITE.nsec,
        };

        let qos = c_qos.as_qos_profile();
        assert_eq!(qos.reliability, QosReliability::BestEffort);
        assert_eq!(qos.durability, QosDurability::TransientLocal);
        assert_eq!(qos.history, QosHistory::KeepAll);
    }

    #[test]
    fn test_null_pointer_returns_none() {
        let result = unsafe { CQosProfile::to_qos_profile(std::ptr::null()) };
        assert!(result.is_none());
    }
}