Struct ConnectionState 

pub struct ConnectionState { /* private fields */ }

The state for a connection accessed through a QuicEndpoint using a QuicConnection component.

Implementations

impl ConnectionState

pub fn get_remote_address(&self) -> SocketAddr

gets the remote address of the connection

pub fn poll_stream_event(&mut self) -> Option<StreamEvent>

Takes the next stream event from the queue.

If this function is not called regularly the queue will grow indefinitely.

pub fn is_drained(&mut self) -> bool

Returns true once there is no longer any need to keep this connection entity around.

pub fn accept_stream(&mut self, direction: Dir) -> Option<StreamId>

Accepts a new stream of a certain direction if one is available.

pub fn open_stream( &mut self, direction: Dir, ) -> Result<StreamId, StreamsExhausted>

Attempts to open a new stream of a certain direction.

Fails if the maximum number of these streams has been reached.

pub fn get_open_send_streams(&mut self) -> usize

Returns the number of send streams that may have unacknowledged data.

Can be used to determine if there is outstanding data that has not been transmitted.

pub fn get_open_remote_streams(&mut self, direction: Dir) -> u64

Gets the number of remotely opened streams of a certain direction.

pub fn set_max_concurrent_streams( &mut self, direction: Dir, count: u64, ) -> Result<(), VarIntBoundsExceeded>

Sets the maximum number of concurrent streams that the peer can open in a certain direction.

pub fn set_send_stream_priority( &mut self, StreamId: StreamId, priority: i32, ) -> Result<(), ClosedStreamError>

Sets the priority of a send stream.

pub fn get_send_stream_priority( &mut self, StreamId: StreamId, ) -> Result<i32, ClosedStreamError>

Gets the priority of a send stream.

pub fn write_send_stream( &mut self, StreamId: StreamId, data: &[u8], ) -> Result<usize, StreamWriteError>

Attempts to write some data to a stream.

If successful returns the number of bytes that were successfully written.

pub fn read_recv_stream( &mut self, StreamId: StreamId, max_size: usize, ordered: bool, ) -> Result<Option<Chunk>, StreamReadError>

Attempts to read up to max_size bytes from a stream.

When none is returned the stream has been finished. If the stream is blocked on waiting for more data StreamReadError::Blocked will be returned.

If an out of order read is attempted, only out of order reads are valid from that point on.

pub fn finish_send_stream( &mut self, StreamId: StreamId, ) -> Result<(), StreamFinishError>

Finishes a send stream

pub fn reset_send_stream( &mut self, StreamId: StreamId, code: u64, ) -> Result<(), ResetStreamError>

Abandon transmitting data on a send stream

pub fn stop_recv_stream( &mut self, StreamId: StreamId, code: u64, ) -> Result<(), StopStreamError>

Will tell the peer to stop sending data on a recv stream

pub fn send_stream_stopped( &mut self, StreamId: StreamId, ) -> Result<Option<u64>, ClosedStreamError>

Checks if a send stream has been stopped by the peer, returns the code if it was.

pub fn close( &mut self, code: u64, reason: Box<[u8]>, ) -> Result<(), VarIntBoundsExceeded>

Closes the connection in the next update

Will do nothing if the stream has already been closed.

pub fn get_datagram_max_size(&mut self) -> Option<usize>

Gets the maximum size datagram that can be sent.

pub fn get_datagram_send_buffer_space(&mut self) -> usize

Gets the amount of space available in the datagram send buffer.

When greater than zero, sending a datagram of at most this size is guaranteed not to cause older datagrams to be dropped.

pub fn send_datagram( &mut self, data: Box<[u8]>, drop_old: bool, ) -> Result<(), SendDatagramError>

Attempts to write an unreliable unordered datagram to an internal buffer.

If drop_old is true the oldest datagram in the buffer will be dropped if more space is needed.

If drop_old is false and the buffer is full [SendDatagramError::Blocked] will be returned.

pub fn receive_datagram(&mut self) -> Option<Box<[u8]>>

Take the next unordered unreliable datagram from the receive buffer.

pub fn accept_uni_stream(&self) -> Option<StreamId>