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

// #![allow(dead_code, unused_mut, unused_imports, unused_variables)]
pub mod datas;
pub mod protocol;
mod tasks;
#[cfg(feature = "tls")]
pub mod tls;
pub mod traits;
pub mod utils;

use protocol::PacketParseError;
pub use tasks::task_client::{data::*, Client, ClientRx};

/// Quality of service
#[repr(u8)]
#[derive(Debug, Clone, Copy, PartialEq, Eq, PartialOrd)]
pub enum QoS {
    AtMostOnce = 0,
    AtLeastOnce = 1,
    ExactlyOnce = 2,
}

#[derive(Debug, Clone)]
pub struct AtMostOnce;

#[derive(Debug, Clone)]
pub struct AtLeastOnce;

#[derive(Debug, Clone)]
pub struct ExactlyOnce;

#[derive(Debug, Clone)]
pub struct ProtocolV4;

#[derive(Debug, Clone)]
pub struct ProtocolV5;

pub trait Protocol {
    fn is_v4() -> bool {
        true
    }
    fn is_v5() -> bool {
        false
    }
}

impl Protocol for ProtocolV4 {}
impl Protocol for ProtocolV5 {
    fn is_v5() -> bool {
        true
    }

    fn is_v4() -> bool {
        false
    }
}

/// Quality of service
#[derive(Debug, Clone, Copy, PartialEq, Eq, PartialOrd)]
pub enum QoSWithPacketId {
    AtMostOnce,
    AtLeastOnce(u16),
    ExactlyOnce(u16),
}

impl QoSWithPacketId {
    pub fn qos(&self) -> u8 {
        match self {
            QoSWithPacketId::AtMostOnce => 0,
            QoSWithPacketId::AtLeastOnce(_) => 1,
            QoSWithPacketId::ExactlyOnce(_) => 2,
        }
    }

    pub fn packet_id(&self) -> Option<u16> {
        match self {
            QoSWithPacketId::AtMostOnce => None,
            QoSWithPacketId::AtLeastOnce(packet_id) => {
                Some(packet_id.clone())
            },
            QoSWithPacketId::ExactlyOnce(packet_id) => {
                Some(packet_id.clone())
            },
        }
    }
}

/// Maps a number to QoS
pub fn qos(num: u8) -> Result<QoS, PacketParseError> {
    match num {
        0 => Ok(QoS::AtMostOnce),
        1 => Ok(QoS::AtLeastOnce),
        2 => Ok(QoS::ExactlyOnce),
        qos => Err(PacketParseError::InvalidQoS(qos)),
    }
}