zerodds-qos 1.0.0-rc.1

DDS QoS policies (DDS 1.4 §2.2.3) + Request/Offered Compatibility-Matrix + PL_CDR_LE PID-Wire-Codec (DDSI-RTPS §9.6.3.2). Pure-Rust no_std + alloc.
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

// SPDX-License-Identifier: Apache-2.0
// Copyright 2026 ZeroDDS Contributors
//! DurabilityServiceQosPolicy (DDS 1.4 §2.2.3.5).
//!
//! Wire-Format: Duration (8) + u32 history_kind (4) + i32 history_depth (4)
//! + 3 × i32 resource_limits (12) = 28 byte.

use zerodds_cdr::{BufferReader, BufferWriter, DecodeError, EncodeError};

use crate::duration::Duration;
use crate::policies::history::HistoryKind;
use crate::policies::resource_limits::LENGTH_UNLIMITED;

/// DurabilityServiceQosPolicy.
#[derive(Debug, Clone, Copy, PartialEq, Eq)]
pub struct DurabilityServiceQosPolicy {
    /// Cleanup-Delay.
    pub service_cleanup_delay: Duration,
    /// History-Kind.
    pub history_kind: HistoryKind,
    /// History-Depth.
    pub history_depth: i32,
    /// Max-Samples.
    pub max_samples: i32,
    /// Max-Instances.
    pub max_instances: i32,
    /// Max-Samples per Instance.
    pub max_samples_per_instance: i32,
}

impl Default for DurabilityServiceQosPolicy {
    fn default() -> Self {
        Self {
            service_cleanup_delay: Duration::ZERO,
            history_kind: HistoryKind::KeepLast,
            history_depth: 1,
            max_samples: LENGTH_UNLIMITED,
            max_instances: LENGTH_UNLIMITED,
            max_samples_per_instance: LENGTH_UNLIMITED,
        }
    }
}

impl DurabilityServiceQosPolicy {
    /// Wire-Encoding.
    ///
    /// # Errors
    /// Buffer-Overflow.
    pub fn encode_into(self, w: &mut BufferWriter) -> Result<(), EncodeError> {
        self.service_cleanup_delay.encode_into(w)?;
        w.write_u32(self.history_kind as u32)?;
        w.write_u32(self.history_depth as u32)?;
        w.write_u32(self.max_samples as u32)?;
        w.write_u32(self.max_instances as u32)?;
        w.write_u32(self.max_samples_per_instance as u32)
    }

    /// Wire-Decoding.
    ///
    /// # Errors
    /// Buffer-Underflow.
    pub fn decode_from(r: &mut BufferReader<'_>) -> Result<Self, DecodeError> {
        let service_cleanup_delay = Duration::decode_from(r)?;
        let v = r.read_u32()?;
        let history_kind = HistoryKind::try_from_u32(v).ok_or(DecodeError::InvalidEnum {
            kind: "HistoryKind",
            value: v,
        })?;
        let history_depth = r.read_u32()? as i32;
        let max_samples = r.read_u32()? as i32;
        let max_instances = r.read_u32()? as i32;
        let max_samples_per_instance = r.read_u32()? as i32;
        Ok(Self {
            service_cleanup_delay,
            history_kind,
            history_depth,
            max_samples,
            max_instances,
            max_samples_per_instance,
        })
    }
}

#[cfg(test)]
#[allow(clippy::unwrap_used)]
mod tests {
    use super::*;
    use zerodds_cdr::Endianness;

    #[test]
    fn default_matches_spec() {
        let d = DurabilityServiceQosPolicy::default();
        assert_eq!(d.service_cleanup_delay, Duration::ZERO);
        assert_eq!(d.history_kind, HistoryKind::KeepLast);
        assert_eq!(d.history_depth, 1);
        assert_eq!(d.max_samples, LENGTH_UNLIMITED);
    }

    #[test]
    fn roundtrip() {
        let p = DurabilityServiceQosPolicy {
            service_cleanup_delay: Duration::from_secs(60),
            history_kind: HistoryKind::KeepAll,
            history_depth: -1,
            max_samples: 100,
            max_instances: 10,
            max_samples_per_instance: 5,
        };
        let mut w = BufferWriter::new(Endianness::Little);
        p.encode_into(&mut w).unwrap();
        let bytes = w.into_bytes();
        assert_eq!(bytes.len(), 28);
        let mut r = BufferReader::new(&bytes, Endianness::Little);
        assert_eq!(DurabilityServiceQosPolicy::decode_from(&mut r).unwrap(), p);
    }
}