Struct SendStream 

pub struct SendStream { /* private fields */ }

A stream that can be used to send bytes. See quinn::SendStream.

This wrapper exists primarily to adapt error codes. WebTransport uses u32 error codes that map into the reserved HTTP/3 error space.

Implementations

impl SendStream

pub fn reset(&mut self, code: u32) -> Result<(), ClosedStream>

Abruptly reset the stream with the provided error code. See quinn::SendStream::reset. WebTransport uses a u32 because it shares the error space with HTTP/3.

pub async fn stopped(&self) -> Result<Option<u32>, SessionError>

Wait until the stream has been stopped and return the error code. See quinn::SendStream::stopped.

Unlike Quinn, this returns None when the code is not a valid WebTransport error code. It also returns SessionError (not StoppedError) because 0-RTT is not supported.

pub async fn write(&mut self, buf: &[u8]) -> Result<usize, WriteError>

Write some data to the stream, returning the size written. See quinn::SendStream::write.

pub async fn write_all(&mut self, buf: &[u8]) -> Result<(), WriteError>

Write all of the data to the stream. See quinn::SendStream::write_all.

pub async fn write_chunks( &mut self, bufs: &mut [Bytes], ) -> Result<Written, WriteError>

Write chunks of data to the stream. See quinn::SendStream::write_chunks.

pub async fn write_chunk(&mut self, buf: Bytes) -> Result<(), WriteError>

Write a chunk of data to the stream. See quinn::SendStream::write_chunk.

pub async fn write_all_chunks( &mut self, bufs: &mut [Bytes], ) -> Result<(), WriteError>

Write all of the chunks of data to the stream. See quinn::SendStream::write_all_chunks.

pub fn finish(&mut self) -> Result<(), ClosedStream>

Mark the stream as finished so no more data can be written. See quinn::SendStream::finish.

WARNING: Quinn implicitly calls this on drop. Dropping futures can lead to incomplete writes, so prefer explicit shutdown when possible.

pub fn set_priority(&self, order: i32) -> Result<(), ClosedStream>

Set stream scheduling priority.

Lower values are generally scheduled earlier by QUIC.

pub fn priority(&self) -> Result<i32, ClosedStream>

Get the current stream scheduling priority.

pub fn quic_id(&self) -> StreamId

Return the underlying QUIC stream ID.

Warning

WebTransport sessions share the QUIC connection with HTTP/3 and other sessions. The quinn::StreamId::index may not increment by 1 as it does in a standalone quinn connection. The JavaScript WebTransport API therefore does not expose stream IDs.

Trait Implementations

impl AsyncWrite for SendStream

fn poll_write( self: Pin<&mut Self>, cx: &mut Context<'_>, buf: &[u8], ) -> Poll<Result<usize>>

Attempt to write bytes from buf into the object.

fn poll_flush(self: Pin<&mut Self>, cx: &mut Context<'_>) -> Poll<Result<()>>

Attempts to flush the object, ensuring that any buffered data reach their destination.

fn poll_shutdown(self: Pin<&mut Self>, cx: &mut Context<'_>) -> Poll<Result<()>>

Initiates or attempts to shut down this writer, returning success when the I/O connection has completely shut down.

fn poll_write_vectored( self: Pin<&mut Self>, cx: &mut Context<'_>, bufs: &[IoSlice<'_>], ) -> Poll<Result<usize, Error>>

Like poll_write, except that it writes from a slice of buffers.

fn is_write_vectored(&self) -> bool

Determines if this writer has an efficient poll_write_vectored implementation.

impl Debug for SendStream

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

Formats the value using the given formatter.

impl SendStream for SendStream

type Error = WriteError

Error type returned by send-side stream operations.

fn set_priority(&mut self, order: u8)

Set the stream’s priority.

fn reset(&mut self, code: u32)

Immediately close the stream and discard any remaining data.

fn finish(&mut self) -> Result<(), Self::Error>

Mark the stream as finished, erroring on any future writes.

async fn write(&mut self, buf: &[u8]) -> Result<usize, Self::Error>

Write some of the buffer to the stream.

async fn write_buf<B: Buf + Send>( &mut self, buf: &mut B, ) -> Result<usize, Self::Error>

Write the given buffer to the stream, advancing the internal position.

async fn write_chunk(&mut self, chunk: Bytes) -> Result<(), Self::Error>

Write the entire Bytes chunk to the stream, potentially avoiding a copy.

async fn closed(&mut self) -> Result<(), Self::Error>

Block until the stream is closed by either side.

fn write_all( &mut self, buf: &[u8], ) -> impl Future<Output = Result<(), Self::Error>> + MaybeSend

Helper to write all data in the buffer.

fn write_all_buf<B>( &mut self, buf: &mut B, ) -> impl Future<Output = Result<(), Self::Error>> + MaybeSend

where B: Buf + MaybeSend,

Helper to write all data in the buffer.