use super::descriptor_body;
use super::lang_text::{EntryReader, LANG_LEN, text_field_len, write_lang, write_text};
use crate::error::{Error, Result};
use crate::text::{DvbText, LangCode};
use alloc::vec::Vec;
use broadcast_common::{Parse, Serialize};
pub const TAG: u8 = 0x5C;
const HEADER_LEN: usize = 2;
#[derive(Debug, Clone, PartialEq, Eq)]
#[cfg_attr(feature = "serde", derive(serde::Serialize))]
#[cfg_attr(feature = "yoke", derive(yoke::Yokeable))]
pub struct BouquetNameEntry<'a> {
pub language_code: LangCode,
pub bouquet_name: DvbText<'a>,
}
#[derive(Debug, Clone, PartialEq, Eq)]
#[cfg_attr(feature = "serde", derive(serde::Serialize))]
#[cfg_attr(feature = "yoke", derive(yoke::Yokeable))]
pub struct MultilingualBouquetNameDescriptor<'a> {
pub entries: Vec<BouquetNameEntry<'a>>,
}
impl<'a> Parse<'a> for MultilingualBouquetNameDescriptor<'a> {
type Error = crate::error::Error;
fn parse(bytes: &'a [u8]) -> Result<Self> {
let body = descriptor_body(
bytes,
TAG,
"MultilingualBouquetNameDescriptor",
"unexpected tag for multilingual_bouquet_name_descriptor",
)?;
let mut entries = Vec::new();
let mut reader = EntryReader::new(body, 0, TAG);
while reader.has_more() {
let language_code = reader.lang()?;
let bouquet_name = reader.text("name_length runs past descriptor end", 0)?;
entries.push(BouquetNameEntry {
language_code,
bouquet_name,
});
}
Ok(Self { entries })
}
}
impl Serialize for MultilingualBouquetNameDescriptor<'_> {
type Error = crate::error::Error;
fn serialized_len(&self) -> usize {
HEADER_LEN
+ self
.entries
.iter()
.map(|e| LANG_LEN + text_field_len(&e.bouquet_name))
.sum::<usize>()
}
fn serialize_into(&self, buf: &mut [u8]) -> Result<usize> {
let len = self.serialized_len();
let body = len - HEADER_LEN;
if buf.len() < len {
return Err(Error::OutputBufferTooSmall {
need: len,
have: buf.len(),
});
}
crate::descriptors::write_descriptor_header(buf, TAG, body)?;
let mut pos = HEADER_LEN;
for e in &self.entries {
pos = write_lang(buf, pos, &e.language_code);
pos = write_text(buf, pos, &e.bouquet_name, "bouquet_name_length")?;
}
Ok(len)
}
}
impl<'a> crate::traits::DescriptorDef<'a> for MultilingualBouquetNameDescriptor<'a> {
const TAG: u8 = TAG;
const NAME: &'static str = "MULTILINGUAL_BOUQUET_NAME";
}
#[cfg(test)]
mod tests {
use super::*;
fn build(entries: &[([u8; 3], &[u8])]) -> Vec<u8> {
let body: usize = entries.iter().map(|(_, n)| LANG_LEN + 1 + n.len()).sum();
let mut v = Vec::with_capacity(HEADER_LEN + body);
v.push(TAG);
v.push(body as u8);
for (lang, name) in entries {
v.extend_from_slice(lang);
v.push(name.len() as u8);
v.extend_from_slice(name);
}
v
}
#[test]
fn parse_single_entry() {
let bytes = build(&[(*b"eng", b"Sky")]);
let d = MultilingualBouquetNameDescriptor::parse(&bytes).unwrap();
assert_eq!(d.entries.len(), 1);
assert_eq!(d.entries[0].language_code, LangCode(*b"eng"));
assert_eq!(d.entries[0].bouquet_name.raw(), b"Sky");
}
#[test]
fn parse_multiple_entries() {
let bytes = build(&[(*b"eng", b"Pack"), (*b"fra", b"Bouquet")]);
let d = MultilingualBouquetNameDescriptor::parse(&bytes).unwrap();
assert_eq!(d.entries.len(), 2);
assert_eq!(d.entries[1].bouquet_name.raw(), b"Bouquet");
}
#[test]
fn parse_rejects_wrong_tag() {
let err = MultilingualBouquetNameDescriptor::parse(&[0x5B, 0]).unwrap_err();
assert!(matches!(err, Error::InvalidDescriptor { tag: 0x5B, .. }));
}
#[test]
fn parse_rejects_short_buffer() {
let err = MultilingualBouquetNameDescriptor::parse(&[TAG]).unwrap_err();
assert!(matches!(err, Error::BufferTooShort { .. }));
}
#[test]
fn parse_rejects_name_length_overrun() {
let bytes = [TAG, 5, b'e', b'n', b'g', 100, 0];
let err = MultilingualBouquetNameDescriptor::parse(&bytes).unwrap_err();
assert!(matches!(err, Error::InvalidDescriptor { .. }));
}
#[test]
fn parse_rejects_truncated_entry_header() {
let bytes = [TAG, 2, b'e', b'n'];
let err = MultilingualBouquetNameDescriptor::parse(&bytes).unwrap_err();
assert!(matches!(err, Error::InvalidDescriptor { .. }));
}
#[test]
fn empty_descriptor_valid() {
let d = MultilingualBouquetNameDescriptor::parse(&[TAG, 0]).unwrap();
assert_eq!(d.entries.len(), 0);
}
#[test]
fn serialize_round_trip() {
let bytes = build(&[(*b"eng", b"Bouquet"), (*b"deu", b"Paket")]);
let parsed = MultilingualBouquetNameDescriptor::parse(&bytes).unwrap();
let mut buf = vec![0u8; parsed.serialized_len()];
parsed.serialize_into(&mut buf).unwrap();
assert_eq!(buf, bytes);
let re = MultilingualBouquetNameDescriptor::parse(&buf).unwrap();
assert_eq!(parsed, re);
}
#[test]
fn serialize_rejects_too_small_buffer() {
let d = MultilingualBouquetNameDescriptor {
entries: vec![BouquetNameEntry {
language_code: LangCode(*b"eng"),
bouquet_name: DvbText::new(b"X"),
}],
};
let mut tiny = [0u8; 3];
let err = d.serialize_into(&mut tiny).unwrap_err();
assert!(matches!(err, Error::OutputBufferTooSmall { .. }));
}
#[test]
fn serialize_rejects_over_range_name() {
let name = vec![0u8; 256];
let d = MultilingualBouquetNameDescriptor {
entries: vec![BouquetNameEntry {
language_code: LangCode(*b"eng"),
bouquet_name: DvbText::new(&name),
}],
};
let mut buf = vec![0u8; d.serialized_len()];
let err = d.serialize_into(&mut buf).unwrap_err();
assert!(matches!(err, Error::FieldOverflow(_)));
}
#[cfg(feature = "serde")]
#[test]
fn serde_serialize_is_stable() {
let d = MultilingualBouquetNameDescriptor {
entries: vec![BouquetNameEntry {
language_code: LangCode(*b"eng"),
bouquet_name: DvbText::new(b"Sky"),
}],
};
let json = serde_json::to_string(&d).unwrap();
assert!(json.contains("\"language_code\""));
assert!(json.contains("\"eng\""));
assert!(json.contains("\"Sky\""));
}
}