Struct StreamInboundState

pub struct StreamInboundState {
    pub buffer: RingBuf<u8>,
    pub buffer_offset: u64,
    pub received: RangeSet,
    pub message_offsets: BTreeMap<u64, Option<u32>>,
    pub is_reliable: bool,
    pub window_limit: u64,
    pub final_offset: Option<u64>,
}

stream inbound buffer

Fields

buffer: RingBuf<u8>

buffer for received data

buffer_offset: u64

stream offset at which buffer starts

received: RangeSet

received segments

message_offsets: BTreeMap<u64, Option<u32>>

offsets into the stream where messages begin, if applicable

is_reliable: bool

whether stream is operating in reliable mode

window_limit: u64

flow control limit

final_offset: Option<u64>

final length of stream (offset of final byte + 1)

Implementations

impl StreamInboundState

pub fn new(initial_window_limit: u64, is_reliable: bool) -> StreamInboundState

create new instance

pub fn receive_segment( &mut self, offset: u64, data: &[u8], ) -> ReceiveSegmentResult

process incoming segment

pub fn set_limit(&mut self, new_limit: u64)

advance window limit

pub fn set_message_marker(&mut self, offset: u64)

set message marker at offset

pub fn set_final_offset(&mut self, offset: u64) -> bool

set final offset from sender

pub fn advance_buffer(&mut self, new_base: u64)

advance buffer, discarding data lower than the new base offset

pub fn read_segment(&self, segment: Range<u64>) -> Option<RingBufSlice<'_, u8>>

read segment from buffer, if available

pub fn max_contiguous_offset(&self) -> Option<u64>

return the highest offset into the stream for which no gaps exist between it and buffer_offset

pub fn read_next(&self, limit: usize) -> Option<RingBufSlice<'_, u8>>

read available bytes from start of buffer

Only really makes sense when is_reliable = true.

pub fn finished(&self) -> bool

check if stream is fully received

If unreliable, will return true as soon as a final offset is received, even if more segments are in transit.