rust-mqtt 0.5.1

MQTT client for embedded and non-embedded environments
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
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125

use core::marker::PhantomData;

use crate::{
    buffer::BufferProvider,
    eio::{Read, Write},
    fmt::trace,
    header::{FixedHeader, PacketType},
    io::{read::BodyReader, write::Writable},
    packet::{Packet, RxError, RxPacket, TxError, TxPacket},
    types::VarByteInt,
    v5::packet::pings::types::{PingPacketType, Req, Resp},
};

mod types;

#[derive(Debug, Clone)]
#[cfg_attr(feature = "defmt", derive(defmt::Format))]
pub struct GenericPingPacket<T: PingPacketType> {
    phantom_data: PhantomData<T>,
}

pub type PingreqPacket = GenericPingPacket<Req>;
pub type PingrespPacket = GenericPingPacket<Resp>;

impl<T: PingPacketType> Packet for GenericPingPacket<T> {
    const PACKET_TYPE: PacketType = T::PACKET_TYPE;
}
impl<'p, T: PingPacketType> RxPacket<'p> for GenericPingPacket<T> {
    async fn receive<R: Read, B: BufferProvider<'p>>(
        header: &FixedHeader,
        _: BodyReader<'_, 'p, R, B>,
    ) -> Result<Self, RxError<R::Error, B::ProvisionError>> {
        trace!("decoding {:?} packet", T::PACKET_TYPE);

        if header.flags() == T::FLAGS {
            Ok(Self {
                phantom_data: PhantomData,
            })
        } else {
            trace!(
                "invalid {:?} fixed header flags: {}",
                T::PACKET_TYPE,
                header.flags()
            );
            Err(RxError::MalformedPacket)
        }
    }
}
impl<T: PingPacketType> TxPacket for GenericPingPacket<T> {
    fn remaining_len(&self) -> VarByteInt {
        // Invariant: 0 < VarByteInt::MAX_ENCODABLE
        VarByteInt::new_unchecked(0)
    }

    async fn send<W: Write>(&self, write: &mut W) -> Result<(), TxError<W::Error>> {
        FixedHeader::new(Self::PACKET_TYPE, T::FLAGS, self.remaining_len())
            .write(write)
            .await?;

        Ok(())
    }
}

impl<T: PingPacketType> GenericPingPacket<T> {
    pub fn new() -> Self {
        Self {
            phantom_data: PhantomData,
        }
    }
}

#[cfg(test)]
mod unit {
    mod req {
        use crate::{
            test::{rx::decode, tx::encode},
            v5::packet::PingreqPacket,
        };

        #[tokio::test]
        #[test_log::test]
        async fn encode() {
            #[rustfmt::skip]
            encode!(
                PingreqPacket::new(),
                [
                    0xC0, //
                    0x00, // remaining length
                ]
            );
        }

        #[tokio::test]
        #[test_log::test]
        async fn decode() {
            decode!(PingreqPacket, 0, [0xC0, 0x00]);
        }
    }

    mod resp {
        use crate::{
            test::{rx::decode, tx::encode},
            v5::packet::PingrespPacket,
        };

        #[tokio::test]
        #[test_log::test]
        async fn encode() {
            #[rustfmt::skip]
            encode!(
                PingrespPacket::new(),
                [
                    0xD0, //
                    0x00, // remaining length
                ]
            );
        }

        #[tokio::test]
        #[test_log::test]
        async fn decode() {
            decode!(PingrespPacket, 0, [0xD0, 0x00]);
        }
    }
}