Enum LinkageData 

#[non_exhaustive]
pub enum LinkageData<'a> {
    MobileHandOver(MobileHandOverInfo),
    EventLinkage(EventLinkageInfo),
    ExtendedEventLinkage(ExtendedEventLinkageInfo),
    None,
    Other(&'a [u8]),
}

Linkage-type-conditional inner data — EN 300 468 §6.2.19.2–4.

Typed variants correspond to the conditional blocks defined in EN 300 468; None covers all other linkage types (no conditional block per the main spec, remaining bytes go to private_data); Other captures the raw tail for linkage types whose conditional structure is defined in companion specs (e.g. TS 102 006 linkage_type 0x09/0x0A, EN 301 192 0x0B/0x0C, EN 303 560 0x20) or user-defined types (0x80..=0xFE) where we cannot distinguish the conditional block from the private_data_byte loop.

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.

MobileHandOver(MobileHandOverInfo)

linkage_type == 0x08 — mobile hand-over info (Table 61).

EventLinkage(EventLinkageInfo)

linkage_type == 0x0D — event linkage info (Table 64).

ExtendedEventLinkage(ExtendedEventLinkageInfo)

linkage_type 0x0E..=0x1F — extended event linkage info (Table 65).

None

No EN 300 468 conditional block — private_data starts immediately after the fixed fields.

Other(&'a [u8])

Raw tail for linkage types with externally-defined or user-defined conditional structure. Because we cannot determine the boundary between the conditional block and the private_data_byte loop, all remaining bytes are captured here and private_data is empty.

Trait Implementations

impl<'a> Clone for LinkageData<'a>

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

Returns a duplicate of the value.

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

Performs copy-assignment from source.

impl<'a> Debug for LinkageData<'a>

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

Formats the value using the given formatter.

impl<'a> Eq for LinkageData<'a>

impl<'a> PartialEq for LinkageData<'a>

fn eq(&self, other: &LinkageData<'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 LinkageData<'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 LinkageData<'a>