Struct smoldot_light::platform::read_write::ReadWrite

pub struct ReadWrite<TNow> {
    pub now: TNow,
    pub incoming_buffer: Vec<u8>,
    pub expected_incoming_bytes: Option<usize>,
    pub read_bytes: usize,
    pub write_buffers: Vec<Vec<u8>>,
    pub write_bytes_queued: usize,
    pub write_bytes_queueable: Option<usize>,
    pub wake_up_after: Option<TNow>,
}

Fields

now: TNow

incoming_buffer: Vec<u8>

Buffer of socket data ready to be processed.

expected_incoming_bytes: Option<usize>

Number of bytes that ReadWrite::incoming_buffer should contain. None if the remote has closed their reading side of the socket.

read_bytes: usize

Total number of bytes that have been read from ReadWrite::incoming_buffer.

ReadWrite::incoming_buffer must have been advanced after these bytes.

write_buffers: Vec<Vec<u8>>

List of buffers containing data to the written out. The consumer of the ReadWrite is expected to add buffers.

write_bytes_queued: usize

Amount of data already queued, both outside and including ReadWrite::write_buffers.

write_bytes_queueable: Option<usize>

Number of additional bytes that are allowed to be pushed to ReadWrite::write_buffers. None if the writing side of the stream is closed.

wake_up_after: Option<TNow>

If Some, the socket must be waken up after the given TNow is reached.

Implementations

impl<TNow> ReadWrite<TNow>

pub fn is_dead(&self) -> bool

Returns true if the connection should be considered dead. That is, both ReadWrite::expected_incoming_bytes is None and ReadWrite::write_bytes_queueable is None.

pub fn close_write(&mut self)

Sets the writing side of the connection to closed.

This is simply a shortcut for setting ReadWrite::write_bytes_queueable to None.

pub fn incoming_buffer_available(&self) -> usize

Returns the size of the data available in the incoming buffer.

pub fn discard_all_incoming(&mut self)

Discards all the incoming data. Updates ReadWrite::read_bytes and decreases ReadWrite::expected_incoming_bytes by the number of consumed bytes.

pub fn incoming_bytes_take( &mut self, num: usize, ) -> Result<Option<Vec<u8>>, IncomingBytesTakeError>

Extract a certain number of bytes from the read buffer.

On success, updates ReadWrite::read_bytes and decreases ReadWrite::expected_incoming_bytes by the number of consumed bytes.

If not enough bytes are available, returns None and sets ReadWrite::expected_incoming_bytes to the requested number of bytes.

pub fn incoming_bytes_take_array<const N: usize>( &mut self, ) -> Result<Option<[u8; N]>, IncomingBytesTakeError>

Same as ReadWrite::incoming_bytes_take_array, but reads a number of bytes as a compile-time constant.

pub fn incoming_bytes_take_leb128( &mut self, max_decoded_number: usize, ) -> Result<Option<usize>, IncomingBytesTakeLeb128Error>

Extract an LEB128-encoded number from the start of the read buffer.

On success, updates ReadWrite::read_bytes and decreases ReadWrite::expected_incoming_bytes by the number of consumed bytes.

If not enough bytes are available, returns None and sets ReadWrite::expected_incoming_bytes to the required number of bytes.

Must be passed the maximum value that this function can return on success. An error is returned if the value sent by the remote is higher than this maximum. This parameter, while not strictly necessary, is here for safety, as it is easy to forget to check the value against a maximum.

pub fn write_from_vec(&mut self, data: &mut Vec<u8>)

Copies as much as possible from the content of data to ReadWrite::write_buffers and updates ReadWrite::write_bytes_queued and ReadWrite::write_bytes_queueable. The bytes that have been written are removed from data.

This function is recommended only if the Vec is small.

pub fn write_from_vec_deque(&mut self, data: &mut VecDeque<u8>)

Copies as much as possible from the content of data to ReadWrite::write_buffers and updates ReadWrite::write_bytes_queued and ReadWrite::write_bytes_queueable. The bytes that have been written are removed from data.

pub fn write_out(&mut self, data: Vec<u8>)

Adds the data to ReadWrite::write_buffers, increases ReadWrite::write_bytes_queued, and decreases ReadWrite::write_bytes_queueable.

Panic

Panics if data.len() > write_bytes_queueable. Panics if the writing side is closed and data isn’t empty.

pub fn wake_up_after(&mut self, after: &TNow)

where TNow: Clone + Ord,

Sets ReadWrite::wake_up_after to min(wake_up_after, after).

pub fn wake_up_asap(&mut self)

where TNow: Clone,

Sets ReadWrite::wake_up_after to the value in ReadWrite::now.