Struct FramedSendStream 

pub struct FramedSendStream {
    inner: SendStream,
    draft: DraftVersion,
    subgroup_io: Option<SubgroupObjectReader>,
    fetch_io: Option<FetchObjectReader>,
}

A framed writer for a send stream. Handles MoQT length-prefixed framing.

Fields

inner: SendStream

draft: DraftVersion

subgroup_io: Option<SubgroupObjectReader>

Stateful subgroup object writer (tracks delta encoding state and extension-presence flag, seeded from the stream’s SubgroupHeader).

fetch_io: Option<FetchObjectReader>

Stateful fetch object writer, seeded from the stream’s FetchHeader. A fetch object inherits fields from the object before it, so the writer has to have seen that object; without this the first one has nothing to inherit from and is refused.

Implementations

impl FramedSendStream

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

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

pub fn stream_id(&self) -> u64

Get the transport-level stream ID.

pub async fn write_control( &mut self, msg: &AnyControlMessage, ) -> Result<Vec<u8>, ConnectionError>

Write a control message to the stream with type+length framing. Returns the raw bytes that were written (for event capture).

pub async fn write_subgroup_header( &mut self, header: &AnySubgroupHeader, ) -> Result<(), ConnectionError>

Write a subgroup stream header. Also initializes the internal delta-encoding state used by FramedSendStream::write_subgroup_object.

The header is refused, and nothing is written, if its fields disagree with its own stream type. That check has to happen here rather than at the first object: the type is what every object after it is framed against, so a header that went out saying the wrong thing cannot be taken back.

pub async fn write_fetch_header( &mut self, header: &AnyFetchHeader, ) -> Result<(), ConnectionError>

Write a fetch response header.

pub async fn write_subgroup_object( &mut self, object: &SubgroupObject, ) -> Result<(), ConnectionError>

Append a draft-15 subgroup object to the stream. Uses the stateful writer seeded from FramedSendStream::write_subgroup_header to produce correct delta-encoded object IDs.

pub async fn write_fetch_object( &mut self, header: &FetchObjectHeader, payload: &[u8], ) -> Result<(), ConnectionError>

Append a fetch object to the stream.

The fetch stream had a header writer and no object writer, so a caller could open one and put nothing on it through this type.

Draft-15 delta-encodes a fetch object against the one before it, so this needs the same stream state the subgroup path keeps, seeded by write_fetch_header. An object that inherits a field from a previous object that does not exist is refused there rather than written as a zero.

The declared length comes from the payload rather than from the caller’s field: a header that disagrees with the bytes beside it desynchronises every object after it on the stream, and nothing downstream can recover.

Errors

ConnectionError::DataStreamState if no fetch header has been written on this stream, and ConnectionError::Codec for a header the writer refuses.

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

Finish the stream (send FIN).

pub fn draft(&self) -> DraftVersion

Returns the draft version this stream is framed for.