Struct Stream 

pub struct Stream<Data> {
    pub stream_id: VarInt,
    pub offset: VarInt,
    pub is_last_frame: bool,
    pub is_fin: bool,
    pub data: Data,
}

Fields

stream_id: VarInt

A variable-length integer indicating the stream ID of the stream

offset: VarInt

A variable-length integer specifying the byte offset in the stream for the data in this STREAM frame.

is_last_frame: bool

If true, the frame is the last frame in the payload

is_fin: bool

If true, the frame marks the end of the stream.

data: Data

The bytes from the designated stream to be delivered.

Implementations

impl<Data> Stream<Data>

pub fn tag(&self) -> u8

pub fn map_data<F: FnOnce(Data) -> Out, Out>(self, map: F) -> Stream<Out>

Converts the stream data from one type to another

impl<Data: EncoderValue> Stream<Data>

pub fn try_fit(&mut self, capacity: usize) -> Result<usize, FitError>

Tries to fit the frame into the provided capacity

The is_last_frame field will be updated with this call.

If ok, the new payload length is returned, otherwise the frame cannot fit.

Trait Implementations

impl<Data> AckElicitable for Stream<Data>

fn ack_elicitation(&self) -> AckElicitation

impl<Data> CongestionControlled for Stream<Data>

fn is_congestion_controlled(&self) -> bool

impl<Data: Debug> Debug for Stream<Data>

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

Formats the value using the given formatter.

impl<'a, Data: DecoderValue<'a>> DecoderParameterizedValue<'a> for Stream<Data>

type Parameter = u8

fn decode_parameterized( tag: Self::Parameter, buffer: DecoderBuffer<'a>, ) -> DecoderBufferResult<'a, Self>

impl<'a, Data: DecoderValueMut<'a>> DecoderParameterizedValueMut<'a> for Stream<Data>

type Parameter = u8

fn decode_parameterized_mut( tag: Self::Parameter, buffer: DecoderBufferMut<'a>, ) -> DecoderBufferMutResult<'a, Self>

impl<Data: EncoderValue> EncoderValue for Stream<Data>

fn encoding_size_for_encoder<E: Encoder>(&self, encoder: &E) -> usize

We hand optimize this encoding size so we can quickly estimate how large a STREAM frame will be

fn encode<E: Encoder>(&self, buffer: &mut E)

Encodes the value into the encoder

fn encode_mut<E>(&mut self, encoder: &mut E)

where E: Encoder,

Encodes the value into the encoder, while potentially mutating the value itself

fn encoding_size(&self) -> usize

Returns the encoding size with no buffer constrains

fn encode_with_len_prefix<Len, E>(&self, encoder: &mut E)

where Len: TryFrom<usize> + EncoderValue, E: Encoder, Self: Sized, <Len as TryFrom<usize>>::Error: Debug,

Encodes the value into the encoder with a prefix of Len

fn encode_to_vec(&self) -> Vec<u8>

impl<'a, AckRanges, Data> From<Stream<Data>> for Frame<'a, AckRanges, Data>

fn from(v: Stream<Data>) -> Frame<'a, AckRanges, Data>

Converts to this type from the input type.

impl<'a> From<Stream<DecoderBuffer<'a>>> for StreamRef<'a>

fn from(s: Stream<DecoderBuffer<'a>>) -> Self

Converts to this type from the input type.

impl<'a> From<Stream<DecoderBufferMut<'a>>> for StreamRef<'a>

fn from(s: Stream<DecoderBufferMut<'a>>) -> Self

Converts to this type from the input type.

impl<'a> From<Stream<DecoderBufferMut<'a>>> for StreamMut<'a>

fn from(s: Stream<DecoderBufferMut<'a>>) -> Self

Converts to this type from the input type.

impl<Data> IntoEvent<Frame> for &Stream<Data>

where Data: EncoderValue,

fn into_event(self) -> Frame

impl<Data: PartialEq> PartialEq for Stream<Data>

fn eq(&self, other: &Stream<Data>) -> bool

Tests for self and other values to be equal, and is used by ==.

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

Tests for !=. The default implementation is almost always sufficient, and should not be overridden without very good reason.

impl<Data> Probing for Stream<Data>

fn path_validation(&self) -> Probe

impl<Data: Eq> Eq for Stream<Data>

impl<Data> StructuralPartialEq for Stream<Data>