Enum FormatSpecifier 

#[non_exhaustive]
pub enum FormatSpecifier<'a> {
    Absent,
    Aggregated {
        module_version: u8,
        module_id: u16,
        block_size: u16,
        module_size: u32,
        compression_method: u8,
        original_size: u32,
        timeout: u8,
        object_key: &'a [u8],
    },
    Other {
        format_id: u8,
        bytes: &'a [u8],
    },
}

FormatSpecifier — the optional aggregated block in a carousel_identifier_descriptor (ISO/IEC 13818-6 / TR 101 202 Table 4.17a).

Dispatch on FormatId:

FormatId	Variant	Meaning
0x00	Absent	No specifier bytes
0x01	Aggregated	Full field set (Table 4.17a)
0x02–0xFF	Other	Reserved/private; raw bytes

This is a data-carrying ADT — the variants hold payloads, not just labels. Use FormatSpecifier::format_id to retrieve the wire FormatId value.

Variants (Non-exhaustive)

Non-exhaustive enums could have additional variants added in future. Therefore, when matching against variants of non-exhaustive enums, an extra wildcard arm must be added to account for any future variants.

Absent

FormatId = 0x00: no FormatSpecifier bytes.

Aggregated

FormatId = 0x01: aggregated FormatSpecifier (TR 101 202 Table 4.17a).

Wire layout of the specifier block (all uimsbf):

ModuleVersion      8
ModuleId          16
BlockSize         16
ModuleSize        32
CompressionMethod  8
OriginalSize      32
TimeOut            8   (8-bit per TR 101 202 v1.2.1)
ObjectKeyLength    8   = N1
ObjectKeyData      8×N1

Fields

module_version: u8

ModuleVersion [7:0] — version of the DSM-CC module.

module_id: u16

ModuleId [15:0] — identity of the DSM-CC module.

block_size: u16

BlockSize [15:0] — download block size in bytes.

module_size: u32

ModuleSize [31:0] — total module size in bytes.

compression_method: u8

CompressionMethod [7:0] — 0x00 = none.

original_size: u32

OriginalSize [31:0] — uncompressed module size in bytes; only meaningful when compression_method != 0x00.

timeout: u8

TimeOut [7:0] — acquisition timeout (8-bit; TR 101 202 v1.2.1).

object_key: &'a [u8]

ObjectKeyData — the object key bytes (ObjectKeyLength bytes).

Other

FormatId = 0x02–0xFF: reserved or private format; carried opaque.

Fields

format_id: u8

The raw FormatId byte.

bytes: &'a [u8]

Raw specifier bytes (remainder after the carousel_id + FormatId prefix, before private_data_byte).

For unknown FormatId values the caller cannot know where the specifier ends and private data begins, so the entire body remainder is treated as specifier bytes and private_data is empty.

Implementations

impl<'a> FormatSpecifier<'a>

pub fn format_id(&self) -> u8

The wire FormatId byte for this variant.

Trait Implementations

impl<'a> Clone for FormatSpecifier<'a>

fn clone(&self) -> FormatSpecifier<'a>

Returns a duplicate of the value.

fn clone_from(&mut self, source: &Self)

Performs copy-assignment from source.

impl<'a> Debug for FormatSpecifier<'a>

fn fmt(&self, f: &mut Formatter<'_>) -> Result

Formats the value using the given formatter.

impl<'a> Eq for FormatSpecifier<'a>

impl<'a> PartialEq for FormatSpecifier<'a>

fn eq(&self, other: &FormatSpecifier<'a>) -> bool

Tests for self and other values to be equal, and is used by ==.

fn ne(&self, other: &Rhs) -> bool

Tests for !=. The default implementation is almost always sufficient, and should not be overridden without very good reason.

impl<'a> Serialize for FormatSpecifier<'a>

fn serialize<__S>(&self, __serializer: __S) -> Result<__S::Ok, __S::Error>

where __S: Serializer,

Serialize this value into the given Serde serializer.

impl<'a> StructuralPartialEq for FormatSpecifier<'a>