dvb_si/descriptors/
private_data_specifier.rs

1//! Private Data Specifier Descriptor — ETSI EN 300 468 §6.2.31 (tag 0x5F).
2//!
3//! Table 85 (PDF p. 98). A single 32-bit `private_data_specifier` value
4//! (registered in EN 300 468 Annex/TR 101 162) that scopes the interpretation
5//! of any subsequent private (user-defined) descriptors in the same loop.
6
7use super::descriptor_body;
8use crate::error::{Error, Result};
9use dvb_common::{Parse, Serialize};
10
11/// Descriptor tag for private_data_specifier_descriptor.
12pub const TAG: u8 = 0x5F;
13const HEADER_LEN: usize = 2;
14/// Fixed payload length: a single 32-bit specifier (EN 300 468 Table 85).
15const BODY_LEN: u8 = 4;
16
17/// Private Data Specifier Descriptor (tag 0x5F).
18#[derive(Debug, Clone, PartialEq, Eq)]
19#[cfg_attr(feature = "serde", derive(serde::Serialize))]
20pub struct PrivateDataSpecifierDescriptor {
21    /// 32-bit registered private_data_specifier (ETSI Table 85, PDF p. 98).
22    pub private_data_specifier: u32,
23}
24
25impl<'a> Parse<'a> for PrivateDataSpecifierDescriptor {
26    type Error = crate::error::Error;
27    fn parse(bytes: &'a [u8]) -> Result<Self> {
28        let body = descriptor_body(
29            bytes,
30            TAG,
31            "PrivateDataSpecifierDescriptor",
32            "unexpected tag for private_data_specifier_descriptor",
33        )?;
34        if body.len() != BODY_LEN as usize {
35            return Err(Error::InvalidDescriptor {
36                tag: TAG,
37                reason: "private_data_specifier_descriptor length must equal 4",
38            });
39        }
40        let private_data_specifier = u32::from_be_bytes([body[0], body[1], body[2], body[3]]);
41        Ok(Self {
42            private_data_specifier,
43        })
44    }
45}
46
47impl Serialize for PrivateDataSpecifierDescriptor {
48    type Error = crate::error::Error;
49    fn serialized_len(&self) -> usize {
50        HEADER_LEN + BODY_LEN as usize
51    }
52
53    fn serialize_into(&self, buf: &mut [u8]) -> Result<usize> {
54        let len = self.serialized_len();
55        if buf.len() < len {
56            return Err(Error::OutputBufferTooSmall {
57                need: len,
58                have: buf.len(),
59            });
60        }
61        buf[0] = TAG;
62        buf[1] = BODY_LEN;
63        buf[HEADER_LEN..HEADER_LEN + 4].copy_from_slice(&self.private_data_specifier.to_be_bytes());
64        Ok(len)
65    }
66}
67impl<'a> crate::traits::DescriptorDef<'a> for PrivateDataSpecifierDescriptor {
68    const TAG: u8 = TAG;
69    const NAME: &'static str = "PRIVATE_DATA_SPECIFIER";
70}
71
72#[cfg(test)]
73mod tests {
74    use super::*;
75
76    #[test]
77    fn parse_extracts_specifier() {
78        let bytes = [TAG, 4, 0x00, 0x00, 0x00, 0x28];
79        let d = PrivateDataSpecifierDescriptor::parse(&bytes).unwrap();
80        assert_eq!(d.private_data_specifier, 0x0000_0028);
81    }
82
83    #[test]
84    fn parse_rejects_wrong_tag() {
85        let err = PrivateDataSpecifierDescriptor::parse(&[0x60, 4, 0, 0, 0, 0]).unwrap_err();
86        assert!(matches!(err, Error::InvalidDescriptor { tag: 0x60, .. }));
87    }
88
89    #[test]
90    fn parse_rejects_short_buffer() {
91        let err = PrivateDataSpecifierDescriptor::parse(&[TAG]).unwrap_err();
92        assert!(matches!(err, Error::BufferTooShort { .. }));
93    }
94
95    #[test]
96    fn parse_rejects_truncated_body() {
97        // length=4 but only 2 payload bytes present.
98        let err = PrivateDataSpecifierDescriptor::parse(&[TAG, 4, 0, 0]).unwrap_err();
99        assert!(matches!(err, Error::BufferTooShort { .. }));
100    }
101
102    #[test]
103    fn parse_rejects_wrong_length() {
104        let err = PrivateDataSpecifierDescriptor::parse(&[TAG, 3, 0, 0, 0]).unwrap_err();
105        assert!(matches!(err, Error::InvalidDescriptor { .. }));
106    }
107
108    #[test]
109    fn serialize_round_trip() {
110        let d = PrivateDataSpecifierDescriptor {
111            private_data_specifier: 0xDEAD_BEEF,
112        };
113        let mut buf = vec![0u8; d.serialized_len()];
114        d.serialize_into(&mut buf).unwrap();
115        let re = PrivateDataSpecifierDescriptor::parse(&buf).unwrap();
116        assert_eq!(d, re);
117    }
118
119    #[test]
120    fn serialize_rejects_too_small_buffer() {
121        let d = PrivateDataSpecifierDescriptor {
122            private_data_specifier: 1,
123        };
124        let mut tiny = [0u8; 3];
125        let err = d.serialize_into(&mut tiny).unwrap_err();
126        assert!(matches!(err, Error::OutputBufferTooSmall { .. }));
127    }
128
129    #[test]
130    fn descriptor_length_matches_payload() {
131        let d = PrivateDataSpecifierDescriptor {
132            private_data_specifier: 0,
133        };
134        assert_eq!(d.serialized_len() - 2, 4);
135    }
136
137    #[cfg(feature = "serde")]
138    #[test]
139    fn serde_round_trip() {
140        let d = PrivateDataSpecifierDescriptor {
141            private_data_specifier: 0x0000_233A,
142        };
143        let json = serde_json::to_string(&d).unwrap();
144        // Serialize-only: assert the emitted JSON re-parses (serialize-stable).
145        let _v: serde_json::Value = serde_json::from_str(&json).unwrap();
146    }
147}
dvb_si/descriptors/private_data_specifier.rs

dvb_si/descriptors/
private_data_specifier.rs
