Enum Packet

pub enum Packet<'a> {
    Connect(Connect<'a>),
    Connack(Connack),
    Publish(Publish<'a>),
    Puback(Pid),
    Pubrec(Pid),
    Pubrel(Pid),
    Pubcomp(Pid),
    Subscribe(Subscribe),
    Suback(Suback),
    Unsubscribe(Unsubscribe),
    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,
                        qospid: QosPid::AtMostOnce,
                        retain: false,
                        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)

MQTT 3.8

Suback(Suback)

MQTT 3.9

Unsubscribe(Unsubscribe)

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.

Trait Implementations

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

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

Returns a duplicate 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

Formats the value using the given formatter.

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

fn from(p: Connack) -> Self

Converts to this type from the input type.

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

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

Converts to this type from the input type.

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

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

Converts to this type from the input type.

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

fn from(p: Suback) -> Self

Converts to this type from the input type.

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

fn from(p: Subscribe) -> Self

Converts to this type from the input type.

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

fn from(p: Unsubscribe) -> Self

Converts to this type from the input type.

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

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