Struct DatagramHeader 

pub struct DatagramHeader {
    pub track_alias: VarInt,
    pub group_id: VarInt,
    pub object_id: VarInt,
    pub publisher_priority: u8,
    pub extension_headers_length: VarInt,
    pub extensions: Vec<u8>,
    pub end_of_group: bool,
}

Fields

track_alias: VarInt

group_id: VarInt

object_id: VarInt

publisher_priority: u8

extension_headers_length: VarInt

extensions: Vec<u8>

end_of_group: bool

Whether this object is the last one in its group.

Draft-12 added this flag and put it in the datagram type rather than in the header body, so it is not written or read by the methods below; DatagramType::is_end_of_group is where it lives on the wire.

Implementations

impl DatagramHeader

pub fn encode(&self, buf: &mut impl BufMut)

Encode the datagram header in the framing that carries no extension block.

Lossy in the same way the subgroup object header is: an extension block this value holds is dropped, because the framing being written has no field for it. The type byte decides which framing is right, and this entry point does not write the type byte, so it cannot consult it. Datagram::encode does both together and never disagrees with itself; this is the piece for a caller that has already written the type.

pub fn encode_with_extensions( &self, has_extensions: bool, buf: &mut impl BufMut, )

pub fn encode_checked(&self, buf: &mut impl BufMut) -> Result<(), CodecError>

Encode the datagram header, refusing what this framing cannot carry.

No status is ever refused, and that is a fact about this draft rather than a check left out. This is the OBJECT_DATAGRAM of Section 9.3.1, whose layout carries no Object Status field at all; a datagram that states a status is the separate OBJECT_DATAGRAM_STATUS message, modelled here as DatagramStatusHeader. So there is no status for Self::encode to drop, and nothing for Section 9.2.1.1’s “Any object with a status code other than zero MUST have an empty payload” to rule on: an object framed this way has status zero by construction.

The extension block is a different matter. Self::encode writes the framing without one, so a block this value holds has nowhere to go, and dropping it silently is what puts a datagram on the wire describing something other than what the caller built. That is refused here.

The fallible signature is also what lets one entry point span every draft. dispatch::AnyDatagramHeader::encode calls this on all thirteen, and the drafts whose payload-bearing datagram does carry a status field need somewhere to say no.

Errors

CodecError::InvalidField if the value carries extension headers, which this framing has no field for.

pub fn decode(buf: &mut impl Buf) -> Result<Self, CodecError>

pub fn decode_with_extensions( has_extensions: bool, buf: &mut impl Buf, ) -> Result<Self, CodecError>

Trait Implementations

impl Clone for DatagramHeader

fn clone(&self) -> DatagramHeader

Returns a duplicate of the value.

fn clone_from(&mut self, source: &Self)

Performs copy-assignment from source.

impl Debug for DatagramHeader

fn fmt(&self, f: &mut Formatter<'_>) -> Result

Formats the value using the given formatter.

impl Eq for DatagramHeader

impl PartialEq for DatagramHeader

fn eq(&self, other: &DatagramHeader) -> bool

Equality operator ==.

fn ne(&self, other: &Rhs) -> bool

Inequality operator !=.

impl StructuralPartialEq for DatagramHeader