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 to_bytes(&self) -> Vec<u8>

where Self::Error: Debug,

Convenience: allocate a Vec and serialise into it.

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. Prefer this over to_bytes for any value that was not obtained by parsing (hand-built values can violate a wire constraint).

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