Struct FramedRecvStream 

pub struct FramedRecvStream {
    inner: RecvStream,
    buf: BytesMut,
    draft: DraftVersion,
    subgroup_io: Option<SubgroupObjectReader>,
    tracking: Option<(TrackObjects, u64)>,
}

A framed reader for a recv stream. Handles MoQT varint-length decoding.

Fields

inner: RecvStream

buf: BytesMut

draft: DraftVersion

subgroup_io: Option<SubgroupObjectReader>

Stateful subgroup object decoder. Initialized by FramedRecvStream::read_subgroup_header and used by FramedRecvStream::read_subgroup_object to track delta-encoded object IDs and whether extension headers are present.

tracking: Option<(TrackObjects, u64)>

The record this stream’s objects are measured against, and the Group ID its header named.

One group for the whole stream: a subgroup header names it once and no object header repeats it. None on a stream that was never given one - a stream for an alias no live binding names, and every stream built outside Connection::accept_subgroup_stream - and such a stream reads exactly as it did before this existed.

Implementations

impl FramedRecvStream

pub fn new(inner: RecvStream, draft: DraftVersion) -> Self

Create a new framed receive stream for the given draft version.

pub fn stream_id(&self) -> u64

Get the transport-level stream ID.

fn measure_objects_against(&mut self, objects: TrackObjects, group: u64)

Measure this stream’s objects against objects, all of them in group.

Called by Connection::accept_subgroup_stream once the header has been read, which is the only point at which both the track and the group are known.

fn note_subgroup_object( &self, object: u64, status: Option<u64>, ) -> Result<(), ConnectionError>

Judge one object this stream carried against where its track ended.

The object’s Group ID is the stream’s and its Object ID is its own, already resolved from the delta the wire carries; what they are measured against is the end an end-of-track object settled on any stream.

async fn fill(&mut self) -> Result<bool, ConnectionError>

Read more data from the stream into the internal buffer.

async fn ensure(&mut self, n: usize) -> Result<(), ConnectionError>

Ensure at least n bytes are available in the buffer.

pub async fn read_control( &mut self, capture_raw: bool, ) -> Result<(AnyControlMessage, Option<Vec<u8>>), ConnectionError>

Read a control message from the stream.

When capture_raw is true, the returned tuple includes a clone of the framed wire bytes (for observer emission). When false, the second element is None and the payload clone is skipped.

pub async fn read_subgroup_header( &mut self, ) -> Result<AnySubgroupHeader, ConnectionError>

Read a subgroup stream header. Also initializes the internal delta-decoding state used by FramedRecvStream::read_subgroup_object.

pub async fn read_fetch_header( &mut self, ) -> Result<AnyFetchHeader, ConnectionError>

Read a fetch response header.

pub async fn read_subgroup_object( &mut self, ) -> Result<SubgroupObject, ConnectionError>

Read the next draft-14 subgroup object from this stream. Uses the stateful reader installed by FramedRecvStream::read_subgroup_header to decode the delta- encoded object ID and handle extension headers per the stream type. Returns an error if called before a subgroup header was read.

pub async fn read_fetch_object( &mut self, ) -> Result<FetchObject, ConnectionError>

Read the next draft-14 fetch object from this stream. Fetch objects are self-describing, so no prior read_fetch_header state is needed to decode each object.

pub fn draft(&self) -> DraftVersion

Returns the draft version this stream is framed for.