Struct s2n_quic_core::datagram::default::Sender

pub struct Sender { /* private fields */ }

A struct to handle sending unreliable datagrams.

The Sender struct contains the queue of unreliable datagrams to be sent. During transmission time, we alternate between sending datagrams and sending stream data. This is to ensure there is a balance between the amount of reliable and unreliable data getting sent.

Datagrams are written to the packet in the order they are added to the queue. A datagram that is too large to fit in the packet will be dropped, unless the packet already contains written datagrams. This attempts to prevent the case where all datagrams are dropped because only a small amount of packet space remains.

Note that there is currently no expiration date for datagrams to live on the queue. Implement the Sender trait if this behavior is necessary for your use-case.

Implementations

impl Sender

pub fn poll_send_datagram( &mut self, data: &mut Bytes, cx: &mut Context<'_> ) -> Poll<Result<(), DatagramError>>

Enqueues a datagram for sending it towards the peer.

Return value

• Poll::Pending if the datagram’s send buffer capacity is currently exhausted and the datagram was not added to the queue. In this case, the caller should retry sending after the Waker on the provided Context is notified.
• Poll::Ready(Ok(())) if the datagram was enqueued for sending.
• Poll::Ready(Err(DatagramError)) if an error occurred while trying to send the datagram.

pub fn send_datagram_forced( &mut self, data: Bytes ) -> Result<Option<Bytes>, DatagramError>

Adds datagrams on the queue to be sent

If the datagram queue is at capacity the oldest datagram will be popped off the queue and returned to make space for the newest datagram.

Return value

• Ok(None) if the datagram was enqueued for sending
• Ok(Some(Bytes)) if the queue is at capacity this will be the oldest datagram on the queue
• Err(DatagramError) if some error occurred

pub fn send_datagram(&mut self, data: Bytes) -> Result<(), DatagramError>

Adds datagrams on the queue to be sent

If the queue is full the newest datagram is not added and an error is returned.

Return value

• Ok() if the datagram was enqueued for sending
• Err(DatagramError) if some error occurred

pub fn retain_datagrams<F>(&mut self, f: F)

where F: FnMut(&Datagram) -> bool,

Filter through the datagrams in the send queue and only keep those that match a predicate

pub fn max_packet_space(&self) -> usize

Returns the largest packet space for datagrams seen during this connection.

Should be used to determine an appropriate datagram size that can be sent in this connection.

pub fn min_packet_space(&self) -> usize

Returns the smallest packet space for datagrams seen during this connection.

Should be used to determine an appropriate datagram size that can be sent in this connection.

pub fn smoothed_packet_space(&self) -> usize

Returns a smoothed calculation of the size of packet space for datagrams seen during this connection.

Should be used to determine an appropriate datagram size that can be sent in this connection.

Trait Implementations

impl Debug for Sender

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

Formats the value using the given formatter.

impl Sender for Sender

fn on_transmit<P: Packet>(&mut self, packet: &mut P)

A callback that allows users to write datagrams directly to the packet

fn has_transmission_interest(&self) -> bool

A callback that checks if a user has datagrams ready to send

fn on_connection_error(&mut self, error: Error)

A callback used to notify the application in the case of a connection error