Struct Unt 

pub struct Unt<'a> {
    pub action_type: u8,
    pub oui_hash: u8,
    pub version_number: u8,
    pub current_next_indicator: bool,
    pub section_number: u8,
    pub last_section_number: u8,
    pub oui: u32,
    pub processing_order: u8,
    pub common_descriptors: &'a [u8],
    pub platform_loop: &'a [u8],
}

Update Notification Table (UNT).

Typed fields cover the fixed header (action_type through processing_order). Variable-length regions are kept as raw &[u8] borrows to avoid pulling in the full ISO/IEC 13818-6 compatibilityDescriptor parser:

• common_descriptors — the body of the common_descriptor_loop(), i.e. the bytes AFTER the 12-bit length field (standard SI descriptor format).
• platform_loop — the entire remaining payload between the common_descriptor_loop and the CRC. This region contains zero or more platform entries, each starting with a compatibilityDescriptor() (an ISO/IEC 13818-6 groupInfo block — not a standard tag/length SI descriptor) followed by a 16-bit platform_loop_length and the corresponding target / operational descriptor loops. Callers that need to walk individual platform entries must parse this field manually.

Fields

action_type: u8

Action type (Table 12 of ETSI TS 102 006): 0x01 = System Software Update, 0x80–0xFF = user defined.

oui_hash: u8

OUI hash: OUI[23:16] ^ OUI[15:8] ^ OUI[7:0] (XOR of the three OUI bytes, used as a quick equality check before comparing the full OUI).

version_number: u8

5-bit version_number of this sub-table.

current_next_indicator: bool

current_next_indicator: true means this section is currently applicable; false means it applies starting from the next version.

section_number: u8

Index of this section within the sub-table.

last_section_number: u8

Index of the last section in the sub-table.

oui: u32

24-bit IEEE Organizationally Unique Identifier.

Stored in the low 24 bits of a u32 (high byte is always zero). The DVB-reserved generic OUI 0x00015A means the receiver should analyse the UNT payload to determine applicability.

processing_order: u8

Processing order (Table 13): 0x00 = first action, 0x01–0xFE = subsequent (ascending), 0xFF = no ordering implied.

common_descriptors: &'a [u8]

Raw body of common_descriptor_loop() — the bytes AFTER the 12-bit length field. Contains zero or more standard SI descriptors (tag + length + payload), as defined in §9.4.2.1.

platform_loop: &'a [u8]

Raw bytes of the entire platform loop region — everything after common_descriptor_loop() up to (but not including) the CRC_32.

Each platform entry starts with a compatibilityDescriptor() block (ISO/IEC 13818-6 §11 groupInfo form — a 2-byte length prefix + descriptor list, not a standard SI tag/length descriptor), followed by a 16-bit platform_loop_length then zero or more platform entries each containing target and operational descriptor loops.

To walk platform entries, parse this field according to ETSI TS 102 006 §9.4.2.2–9.4.2.4.

Trait Implementations

impl<'a> Clone for Unt<'a>

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

Returns a duplicate of the value.

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

Performs copy-assignment from source.

impl<'a> Debug for Unt<'a>

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

Formats the value using the given formatter.

impl<'de: 'a, 'a> Deserialize<'de> for Unt<'a>

fn deserialize<__D>(__deserializer: __D) -> Result<Self, __D::Error>

where __D: Deserializer<'de>,

Deserialize this value from the given Serde deserializer.

impl<'a> Eq for Unt<'a>

impl<'a> From<Unt<'a>> for AnyTable<'a>

fn from(t: Unt<'a>) -> Self

Converts to this type from the input type.

impl<'a> Parse<'a> for Unt<'a>

type Error = Error

The error type this implementer returns. Typically the enclosing crate’s Error enum.

fn parse(bytes: &'a [u8]) -> Result<Self>

Parse bytes as Self. Returns Err(Self::Error) on any protocol violation or buffer underrun.

impl<'a> PartialEq for Unt<'a>

fn eq(&self, other: &Unt<'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 Serialize for Unt<'_>

type Error = Error

The error type this implementer returns (usually the same as the corresponding Parse impl, but need not be).

fn serialized_len(&self) -> usize

Number of bytes serialize_into will write.

fn serialize_into(&self, buf: &mut [u8]) -> Result<usize>

Write the serialised form into buf. Returns the number of bytes written (always equal to serialized_len()).

fn to_bytes(&self) -> Vec<u8>

where Self::Error: Debug,

Convenience: allocate a Vec and serialise into it. Panics only if serialize_into misreports serialized_len() — a contract every implementer is responsible for upholding.

impl<'a> Serialize for Unt<'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 Unt<'a>

impl<'a> Table<'a> for Unt<'a>

const TABLE_ID: u8 = TABLE_ID

Expected table_id for this table.

const PID: u16 = PID

PID on which this table is typically carried.

impl<'a> TableDef<'a> for Unt<'a>

const TABLE_ID_RANGES: &'static [(u8, u8)]

Inclusive (lo, hi) table_id ranges this type parses.

const NAME: &'static str = "UPDATE_NOTIFICATION"

Spec name for diagnostics. SCREAMING_SNAKE, suffix-free: PROGRAM_ASSOCIATION, EVENT_INFORMATION, SERVICE_DESCRIPTION.