Struct FramedSendStream 

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

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.

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-18 subgroup object to the stream using the stateful writer seeded from FramedSendStream::write_subgroup_header.

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. The subgroup stream has had both since the writer was introduced.

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::Codec if the header’s fields disagree with the Serialization Flags that announce them, which the encoder refuses rather than writing a frame its own reader cannot take apart.

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

Finish the stream (send FIN).

pub fn reset(&mut self, code: u64) -> Result<(), ConnectionError>

Reset the stream with code, telling the peer transmission was abandoned rather than completed.

Dropping a send stream sends a FIN, which claims the stream ended cleanly; this is the only way to say the opposite. See SendStream::reset.

pub fn draft(&self) -> DraftVersion

Returns the draft version this stream is framed for.