Enum TransportState

#[non_exhaustive]
pub enum TransportState {
    Idle,
    Assembling,
    Message(MessageResult),
}

SAME Transport Layer Status

SAME messages may be built from one, two, or three repetitions of (hopefully) identical retransmissions. Each burst is passed to the transport layer for processing.

1. When the transport layer receives its first burst, the state becomes Assembling.

2. The modem waits for some time after the last burst is received to ensure it has the best decode possible.

3. After this deadline passes, and a sufficient number of bursts are received, a Message is reported. If the decode failed, this Message might be an error.

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.

Idle

The assembler has not read enough bursts for a message

Assembling

The assembler is building a message

One or more bursts are stored in the history, but the assembler needs more before it can output a message.

Message(MessageResult)

A fully-assembled message or error is ready to report

Trait Implementations

impl AsRef<str> for TransportState

fn as_ref(&self) -> &str

Converts this type into a shared reference of the (usually inferred) input type.

impl Clone for TransportState

fn clone(&self) -> TransportState

Returns a duplicate of the value.

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

Performs copy-assignment from source.

impl Debug for TransportState

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

Formats the value using the given formatter.

impl Display for TransportState

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

Formats the value using the given formatter.

impl From<TransportState> for SameEventType

fn from(inp: TransportState) -> Self

Converts to this type from the input type.

impl Hash for TransportState

fn hash<__H: Hasher>(&self, state: &mut __H)

Feeds this value into the given Hasher.

fn hash_slice<H>(data: &[Self], state: &mut H)

where H: Hasher, Self: Sized,

Feeds a slice of this type into the given Hasher.

impl PartialEq for TransportState

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

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

const 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 Eq for TransportState

impl StructuralPartialEq for TransportState