mqute-codec 0.4.2

A full-featured implementation of MQTT protocol serialization in Rust, supporting versions 3.1, 3.1.1 and 5.0.
Documentation 
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91

//! # MQTT Packet Type
//!
//! This module provides an enum to represent the types of MQTT packets and utilities
//! for converting between packet types and their corresponding numeric values.
//!
//! The `PacketType` enum represents the types of MQTT packets as defined by the MQTT protocol.
//! Each packet type corresponds to a specific numeric value, which is used in the fixed header
//! of MQTT packets.

use crate::Error;

/// Represents the type of MQTT packet.
///
/// Each packet type corresponds to a specific numeric value, as defined by the MQTT protocol.
#[derive(Debug, Clone, Copy, PartialEq, Eq)]
pub enum PacketType {
    /// Client request to connect to the server.
    Connect = 1,
    /// Connect acknowledgment.
    ConnAck,
    /// Publish message.
    Publish,
    /// Publish acknowledgment.
    PubAck,
    /// Publish received (assured delivery part 1).
    PubRec,
    /// Publish release (assured delivery part 2).
    PubRel,
    /// Publish complete (assured delivery part 3).
    PubComp,
    /// Client subscribe request.
    Subscribe,
    /// Subscribe acknowledgment.
    SubAck,
    /// Unsubscribe request.
    Unsubscribe,
    /// Unsubscribe acknowledgment.
    UnsubAck,
    /// PING request.
    PingReq,
    /// PING response.
    PingResp,
    /// Client is disconnecting.
    Disconnect,
    /// Authentication exchange.
    Auth,
}

impl TryFrom<u8> for PacketType {
    type Error = Error;

    /// Attempts to convert a numeric value into a `PacketType` enum.
    ///
    /// # Errors
    /// Returns an `Error::InvalidPacketType` if the value is not a valid packet type.
    ///
    /// # Examples
    ///
    /// ```rust
    /// use mqute_codec::protocol::PacketType;
    /// use mqute_codec::Error;
    ///
    /// let packet_type = PacketType::try_from(3).unwrap();
    /// assert_eq!(packet_type, PacketType::Publish);
    ///
    /// let result = PacketType::try_from(16);
    /// assert!(result.is_err());
    /// ```
    fn try_from(value: u8) -> Result<Self, Self::Error> {
        let packet_type = match value {
            1 => PacketType::Connect,
            2 => PacketType::ConnAck,
            3 => PacketType::Publish,
            4 => PacketType::PubAck,
            5 => PacketType::PubRec,
            6 => PacketType::PubRel,
            7 => PacketType::PubComp,
            8 => PacketType::Subscribe,
            9 => PacketType::SubAck,
            10 => PacketType::Unsubscribe,
            11 => PacketType::UnsubAck,
            12 => PacketType::PingReq,
            13 => PacketType::PingResp,
            14 => PacketType::Disconnect,
            15 => PacketType::Auth,
            _ => return Err(Error::InvalidPacketType(value)),
        };

        Ok(packet_type)
    }
}