Struct StreamHandler 

pub struct StreamHandler { /* private fields */ }

Handler for an individual QUIC stream (bidirectional)

Implementations

impl StreamHandler

pub fn new(send: SendStream, recv: RecvStream) -> Self

pub async fn read_frame(&mut self) -> Result<Frame, ServerError>

Read the next frame from the stream

pub async fn write_frame(&mut self, frame: &Frame) -> Result<(), ServerError>

Write a frame to the stream

pub async fn handle_request<Req, Resp, H, Fut>( &mut self, handler: H, ) -> Result<(), ServerError>

where Req: Message + Default, Resp: Message, H: FnOnce(Req) -> Fut, Fut: Future<Output = Result<Resp, ServerError>>,

Handle a request/response pattern

pub fn into_framed(self) -> FramedStream<(SendStream, RecvStream)>

Convert to a FramedStream for more complex patterns

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

Finish the send stream (signal no more data)

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

Read raw bytes from the stream (for streaming uploads) Returns the number of bytes read, or 0 if EOF

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

Read exact number of bytes from the stream

pub async fn read_to_end( &mut self, size_limit: usize, ) -> Result<Vec<u8>, ServerError>

Read all remaining bytes from the stream until EOF (with size limit)

pub async fn stream_to_writer<W: AsyncWrite + Unpin>( &mut self, writer: &mut W, expected_size: Option<u64>, ) -> Result<u64, ServerError>

Stream bytes to a writer (for large uploads without buffering all in memory)