Struct SessionSender 

pub struct SessionSender<T> { /* private fields */ }

Available on crate features http and std only.

The sending half of an HttpDatagramSession.

Implementations

impl<T> SessionSender<T>

where T: AsyncWrite,

pub async fn send_datagram( &mut self, payload: Bytes, ) -> Result<DatagramTransport, SessionError>

Send an HTTP Datagram.

With a negotiated native carrier the datagram is handed to it without waiting and may be lost; a payload above the current native maximum fails with NativeSendError::TooLarge, and a closed association with NativeSendError::Closed, rather than silently switching to reliable delivery (RFC 9297 §3.5). Otherwise it is written as a DATAGRAM capsule, waiting for data-stream flow control.

pub async fn send_capsule( &mut self, ty: CapsuleType, value: Bytes, ) -> Result<(), SessionError>

Send a complete capsule on the reliable data stream and flush it.

pub async fn start_capsule( &mut self, header: CapsuleHeader, ) -> Result<(), SessionError>

Begin forwarding one capsule whose value arrives in chunks through send_capsule_data.

Until the declared length is supplied, other capsules, capsule-carried datagrams and close are rejected with SessionError::CapsuleInProgress; native datagrams are unaffected. Forwarding preserves type, length and value; integers are re-encoded minimally.

pub async fn send_capsule_data( &mut self, chunk: Bytes, ) -> Result<(), SessionError>

Append value bytes to the capsule begun by start_capsule.

A chunk beyond the declared length is rejected with SessionError::CapsuleLengthMismatch and the capsule stays open.

pub async fn close(&mut self) -> Result<(), SessionError>

Write any accepted bytes, then finish the data stream cleanly.

Only the local direction ends; receiving continues until the peer ends its own. Once the end is committed, sends return SessionError::SendClosed and calling close again resumes finishing the stream.

Trait Implementations

impl<T> Debug for SessionSender<T>

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

Formats the value using the given formatter.

impl<T> Drop for SessionSender<T>

fn drop(&mut self)

Executes the destructor for this type.

fn pin_drop(self: Pin<&mut Self>)

🔬This is a nightly-only experimental API. (pin_ergonomics)

Execute the destructor for this type, but different to Drop::drop, it requires self to be pinned.