Enum StatusQueryApdu 

#[non_exhaustive]
pub enum StatusQueryApdu<'a> {
    StatusQueryReq(StatusQueryReq),
    TrapReq(TrapReq),
    GetNextItemReq(GetNextItemReq),
    GetNextItemAck(GetNextItemAck),
    StatusAck(StatusAck<'a>),
}

Resource-scoped dispatch over the Status Query objects (Tables 37-41).

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.

StatusQueryReq(StatusQueryReq)

StatusQueryReq (9F 80 00).

TrapReq(TrapReq)

TrapReq (9F 80 01).

GetNextItemReq(GetNextItemReq)

GetNextItemReq (9F 80 02).

GetNextItemAck(GetNextItemAck)

GetNextItemAck (9F 80 03).

StatusAck(StatusAck<'a>)

StatusAck (9F 80 04).

Implementations

impl<'a> StatusQueryApdu<'a>

pub const TAGS: &'static [ApduTag]

Every apdu_tag this enum dispatches, in declaration order.

pub fn tag(&self) -> ApduTag

The apdu_tag of the contained object (the list line it was declared with).

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

Parse an APDU, dispatching on the leading apdu_tag.

Trait Implementations

impl<'a> Clone for StatusQueryApdu<'a>

fn clone(&self) -> Self

Returns a duplicate of the value.

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

Performs copy-assignment from source.

impl<'a> Debug for StatusQueryApdu<'a>

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

Formats the value using the given formatter.

impl<'a> Eq for StatusQueryApdu<'a>

impl<'a> PartialEq for StatusQueryApdu<'a>

fn eq(&self, other: &Self) -> bool

Equality operator ==.

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

Inequality operator !=.

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

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 try_to_bytes(&self) -> Result<Vec<u8>, Self::Error>

Allocate a Vec and serialize into it, returning the serializer’s error instead of panicking. This is the only allocate-and-serialize entry point: there is deliberately no panicking to_bytes (hand-built values, or values assembled from damaged wire data, can violate a wire constraint, so the error must reach the caller).

impl<'a> StructuralPartialEq for StatusQueryApdu<'a>