Enum minimq::types::Properties

pub enum Properties<'a> {
    Slice(&'a [Property<'a>]),
    DataBlock(&'a [u8]),
    CorrelatedSlice {
        correlation: Property<'a>,
        properties: &'a [Property<'a>],
    },
}

Variants

Slice(&'a [Property<'a>])

Properties ready for transmission are provided as a list of properties that will be later encoded into a packet.

DataBlock(&'a [u8])

Properties have an unknown size when being received. As such, we store them as a binary blob that we iterate across.

CorrelatedSlice

Properties that are correlated to a previous message.

Fields

correlation: Property<'a>

properties: &'a [Property<'a>]

Implementations

impl<'a> Properties<'a>

pub fn size(&self) -> usize

The length in bytes of the serialized properties.

Trait Implementations

impl<'a> Debug for Properties<'a>

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

Formats the value using the given formatter.

impl<'a, 'de: 'a> Deserialize<'de> for Properties<'a>

fn deserialize<D: Deserializer<'de>>(deserializer: D) -> Result<Self, D::Error>

Deserialize this value from the given Serde deserializer.

impl<'a> IntoIterator for &'a Properties<'a>

type Item = Result<Property<'a>, ProtocolError>

The type of the elements being iterated over.

type IntoIter = PropertiesIter<'a>

Which kind of iterator are we turning this into?

fn into_iter(self) -> PropertiesIter<'a>

Creates an iterator from a value.

impl<'a> PartialEq for Properties<'a>

fn eq(&self, other: &Properties<'a>) -> bool

This method tests for self and other values to be equal, and is used by ==.

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

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

impl<'a> Serialize for Properties<'a>

fn serialize<S: Serializer>(&self, serializer: S) -> Result<S::Ok, S::Error>

Serialize this value into the given Serde serializer.

impl<'a> StructuralPartialEq for Properties<'a>