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

use crate::{
    buffer::BufferProvider,
    eio::Read,
    header::FixedHeader,
    io::{
        err::{BodyReadError, ReadError},
        read::BodyReader,
    },
    packet::Packet,
    v5::property::AtMostOncePropertyError,
};

pub trait RxPacket<'p>: Packet + Sized {
    /// Receives a packet. Must check the fixed header for correctness.
    async fn receive<R: Read, B: BufferProvider<'p>>(
        header: &FixedHeader,
        reader: BodyReader<'_, 'p, R, B>,
    ) -> Result<Self, RxError<R::Error, B::ProvisionError>>;
}

#[derive(Debug)]
#[cfg_attr(feature = "defmt", derive(defmt::Format))]
pub enum RxError<E, B> {
    Read(E),
    Buffer(B),

    UnexpectedEOF,

    MalformedPacket,
    ProtocolError,
    InvalidTopicName,
}

impl<E, B: core::fmt::Debug> From<BodyReadError<E, B>> for RxError<E, B> {
    fn from(e: BodyReadError<E, B>) -> Self {
        match e {
            BodyReadError::Read(e) => Self::Read(e),
            BodyReadError::Buffer(b) => Self::Buffer(b),
            BodyReadError::UnexpectedEOF => Self::UnexpectedEOF,
            BodyReadError::InsufficientRemainingLen => Self::MalformedPacket,
            BodyReadError::MalformedPacket => Self::MalformedPacket,
            BodyReadError::ProtocolError => Self::ProtocolError,
            BodyReadError::InvalidTopicName => Self::InvalidTopicName,
        }
    }
}
impl<E, B: core::fmt::Debug> From<ReadError<BodyReadError<E, B>>> for RxError<E, B> {
    fn from(e: ReadError<BodyReadError<E, B>>) -> Self {
        match e {
            ReadError::Read(e) => e.into(),
            ReadError::UnexpectedEOF => Self::UnexpectedEOF,
            ReadError::MalformedPacket => Self::MalformedPacket,
            ReadError::ProtocolError => Self::ProtocolError,
            ReadError::InvalidTopicName => Self::InvalidTopicName,
        }
    }
}
impl<E, B: core::fmt::Debug> From<ReadError<E>> for RxError<E, B> {
    fn from(e: ReadError<E>) -> Self {
        match e {
            ReadError::Read(e) => Self::Read(e),
            ReadError::UnexpectedEOF => Self::UnexpectedEOF,
            ReadError::MalformedPacket => Self::MalformedPacket,
            ReadError::ProtocolError => Self::ProtocolError,
            ReadError::InvalidTopicName => Self::InvalidTopicName,
        }
    }
}
impl<E, B: core::fmt::Debug> From<AtMostOncePropertyError<ReadError<BodyReadError<E, B>>>>
    for RxError<E, B>
{
    fn from(e: AtMostOncePropertyError<ReadError<BodyReadError<E, B>>>) -> Self {
        match e {
            AtMostOncePropertyError::Read(e) => e.into(),
            AtMostOncePropertyError::AlreadySet => Self::ProtocolError,
        }
    }
}