Struct Runner 

pub struct Runner<'d> { /* private fields */ }

Channel runner.

Holds the shared state and the lower end of channels for inbound and outbound packets.

Implementations

impl<'d> Runner<'d>

pub fn split(self) -> (StateRunner<'d>, RxRunner<'d>, TxRunner<'d>)

Split the runner into separate runners for controlling state, rx and tx.

pub fn borrow_split(&mut self) -> (StateRunner<'_>, RxRunner<'_>, TxRunner<'_>)

Split the runner into separate runners for controlling state, rx and tx borrowing the underlying state.

pub fn state_runner(&self) -> StateRunner<'d>

Create a state runner sharing the state channel.

pub fn set_link_state(&mut self, state: LinkState)

Set the link state.

pub fn set_hardware_address(&mut self, address: HardwareAddress)

Set the hardware address.

pub async fn rx_ready(&mut self)

Wait until there is space in the inbound queue.

pub fn poll_rx_ready(&mut self, cx: &mut Context<'_>) -> Poll<()>

Poll whether there is space in the inbound queue.

pub async fn rx_buf(&mut self) -> PacketBuf

Wait for an empty buffer from the stack, to receive a packet into.

The buffer has zero length. Its capacity is the stack’s packet buffer size, which may be smaller than the MTU.

Push it back filled with rx, or drop it to give it back to the stack’s pool.

pub fn try_rx_buf(&mut self) -> Option<PacketBuf>

Get an empty buffer from the stack, if there is one right now.

See rx_buf.

pub fn poll_rx_buf(&mut self, cx: &mut Context<'_>) -> Poll<PacketBuf>

Poll for an empty buffer from the stack.

See rx_buf.

pub async fn rx(&mut self, buf: PacketBuf)

Push a received packet to the stack, waiting for space in the inbound queue.

pub fn try_rx(&mut self, buf: PacketBuf) -> Result<(), PacketBuf>

Push a received packet to the stack, if the inbound queue has space right now.

If it doesn’t, the buffer is handed back in the Err variant.

pub async fn tx(&mut self) -> PacketBuf

Wait for a packet the stack wants to transmit.

pub fn try_tx(&mut self) -> Option<PacketBuf>

Get a packet the stack wants to transmit, if there is one right now.

pub fn poll_tx(&mut self, cx: &mut Context<'_>) -> Poll<PacketBuf>

Poll for a packet the stack wants to transmit.