Struct SendBuffer 

pub struct SendBuffer {
    pub max_message_size: usize,
    pub max_chunk_count: usize,
    pub send_buffer_size: usize,
    /* private fields */
}

General implementation of a buffer of outgoing messages.

Fields

max_message_size: usize

Maximum size of a message, total. Use 0 for no limit

max_chunk_count: usize

Maximum number of chunks in a message.

send_buffer_size: usize

Maximum size of each individual chunk.

Implementations

impl SendBuffer

pub fn new( buffer_size: usize, max_message_size: usize, max_chunk_count: usize, sequence_numbers_legacy: bool, ) -> SendBuffer

Create a new send buffer with the given initial limits.

pub fn encode_next_chunk( &mut self, secure_channel: &SecureChannel, ) -> Result<(), StatusCode>

Encode the next chunk in the queue to the out-buffer.

pub fn set_sequence_number_legacy(&mut self, is_legacy: bool)

Set whether we are using legacy sequence numbers or not. This depends on the active security policy.

pub fn write_error(&mut self, error: ErrorMessage)

Clear the list of pending messages, then add an error.

pub fn write_ack(&mut self, ack: AcknowledgeMessage)

Write an acknowledge message to the list of pending messages.

pub fn write( &mut self, request_id: u32, message: impl Message, secure_channel: &SecureChannel, ) -> Result<u32, Error>

Encode a message to chunks, then write them to the pending message queue.

The messages are encrypted as they are sent.

pub fn next_request_id(&mut self) -> u32

Get the next request ID.

pub async fn read_into_async( &mut self, write: &mut (impl AsyncWrite + Unpin), ) -> Result<(), Error>

Read the pending buffer into the given stream.

pub fn should_encode_chunks(&self) -> bool

Return true if we should encode a new chunk.

pub fn can_read(&self) -> bool

Check if we can read data from the buffer into the stream.

pub fn revise( &mut self, send_buffer_size: usize, max_message_size: usize, max_chunk_count: usize, )

Revise the limits with the result of a hello/acknowledge message.