Enum mqttrust_core::Packet

pub enum Packet<'a> {
    Connect(Connect<'a>),
    Connack(Connack),
    Publish(Publish<'a>),
    Puback(Pid),
    Pubrec(Pid),
    Pubrel(Pid),
    Pubcomp(Pid),
    Subscribe(Subscribe<'a>),
    Suback(Suback<'a>),
    Unsubscribe(Unsubscribe<'a>),
    Unsuback(Pid),
    Pingreq,
    Pingresp,
    Disconnect,
}

Base enum for all MQTT packet types.

This is the main type you’ll be interacting with, as an output of decode_slice() and an input of encode(). Most variants can be constructed directly without using methods.

// Simplest form
let pkt = Packet::Connack(Connack { session_present: false,
                                    code: ConnectReturnCode::Accepted });
// Using `Into` trait
let publish = Publish { dup: false,
                        qos: QoS::AtMostOnce,
                        retain: false,
                        pid: None,
                        topic_name: "to/pic",
                        payload: b"payload" };
let pkt: Packet = publish.into();
// Identifyer-only packets
let pkt = Packet::Puback(Pid::try_from(42).unwrap());

Variants

Connect(Connect<'a>)

MQTT 3.1

Connack(Connack)

MQTT 3.2

Publish(Publish<'a>)

MQTT 3.3

Puback(Pid)

MQTT 3.4

Pubrec(Pid)

MQTT 3.5

Pubrel(Pid)

MQTT 3.6

Pubcomp(Pid)

MQTT 3.7

Subscribe(Subscribe<'a>)

MQTT 3.8

Suback(Suback<'a>)

MQTT 3.9

Unsubscribe(Unsubscribe<'a>)

MQTT 3.10

Unsuback(Pid)

MQTT 3.11

Pingreq

MQTT 3.12

Pingresp

MQTT 3.13

Disconnect

MQTT 3.14

Implementations

impl<'a> Packet<'a>

pub fn get_type(&self) -> PacketType

Return the packet type variant.

This can be used for matching, categorising, debuging, etc. Most users will match directly on Packet instead.

pub fn len(&self) -> usize

Trait Implementations

impl<'a> Clone for Packet<'a>

fn clone(&self) -> Packet<'a>

Returns a copy of the value.

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

Performs copy-assignment from source.

impl<'a> Debug for Packet<'a>

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

Formats the value using the given formatter.

impl<'a> From<Connack> for Packet<'a>

fn from(p: Connack) -> Packet<'a>

Converts to this type from the input type.

impl<'a> From<Connect<'a>> for Packet<'a>

fn from(p: Connect<'a>) -> Packet<'a>

Converts to this type from the input type.

impl<'a> From<Publish<'a>> for Packet<'a>

fn from(p: Publish<'a>) -> Packet<'a>

Converts to this type from the input type.

impl<'a> From<Suback<'a>> for Packet<'a>

fn from(p: Suback<'a>) -> Packet<'a>

Converts to this type from the input type.

impl<'a> From<Subscribe<'a>> for Packet<'a>

fn from(p: Subscribe<'a>) -> Packet<'a>

Converts to this type from the input type.

impl<'a> From<Unsubscribe<'a>> for Packet<'a>

fn from(p: Unsubscribe<'a>) -> Packet<'a>

Converts to this type from the input type.

impl<'a> PartialEq<Packet<'a>> for Packet<'a>

fn eq(&self, other: &Packet<'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> StructuralPartialEq for Packet<'a>