cloudmqtt 0.4.0

A pure Rust MQTT client and server library
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

//
//   This Source Code Form is subject to the terms of the Mozilla Public
//   License, v. 2.0. If a copy of the MPL was not distributed with this
//   file, You can obtain one at http://mozilla.org/MPL/2.0/.
//
use std::sync::Arc;

use bytes::Bytes;
use mqtt_format::v3::packet::MPacket;
use yoke::{Yoke, Yokeable};

#[derive(Clone)]
pub struct MqttPacket {
    packet: Yoke<MPacket<'static>, Arc<Bytes>>,
}

impl std::fmt::Debug for MqttPacket {
    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
        f.debug_struct("MqttPacket")
            .field("packet", self.packet.get())
            .finish()
    }
}

impl MqttPacket {
    pub fn get_packet(&self) -> &MPacket<'_> {
        self.packet.get()
    }

    pub(crate) fn new(packet: Yoke<MPacket<'static>, Arc<Bytes>>) -> MqttPacket {
        MqttPacket { packet }
    }
}

pub struct MqttSubPacket<P>
where
    P: for<'a> yoke::Yokeable<'a>,
    P: Clone,
{
    packet: Yoke<P, Arc<Bytes>>,
}

impl<P> Clone for MqttSubPacket<P>
where
    P: for<'a> yoke::Yokeable<'a>,
    P: Clone,
    for<'a> yoke::trait_hack::YokeTraitHack<<P as Yokeable<'a>>::Output>: Clone,
{
    fn clone(&self) -> Self {
        Self {
            packet: self.packet.clone(),
        }
    }
}

impl<P> MqttSubPacket<P>
where
    P: for<'a> yoke::Yokeable<'a>,
    P: Clone,
{
    pub fn get_packet(&self) -> &<P as Yokeable<'_>>::Output {
        self.packet.get()
    }
}

pub trait IntoMqttSubPacket<Target>: Sized
where
    Target: for<'a> Yokeable<'a>,
    Target: Clone,
{
    fn into_mqtt_sub_packet(self) -> Option<MqttSubPacket<Target>>;
}

macro_rules! impl_sub_packet_conversion {
    ($name:ty) => {
        impl IntoMqttSubPacket<$name> for MqttPacket {
            fn into_mqtt_sub_packet(self) -> Option<MqttSubPacket<$name>> {
                let packet = self
                    .packet
                    .try_map_project(|packet, _| packet.try_into())
                    .ok()?;

                Some(MqttSubPacket { packet })
            }
        }
    };
}

impl_sub_packet_conversion!(mqtt_format::v3::packet::MConnect<'static>);
impl_sub_packet_conversion!(mqtt_format::v3::packet::MConnack);
impl_sub_packet_conversion!(mqtt_format::v3::packet::MPublish<'static>);
impl_sub_packet_conversion!(mqtt_format::v3::packet::MPuback);
impl_sub_packet_conversion!(mqtt_format::v3::packet::MPubrec);
impl_sub_packet_conversion!(mqtt_format::v3::packet::MPubrel);
impl_sub_packet_conversion!(mqtt_format::v3::packet::MPubcomp);
impl_sub_packet_conversion!(mqtt_format::v3::packet::MSubscribe<'static>);
impl_sub_packet_conversion!(mqtt_format::v3::packet::MSuback<'static>);
impl_sub_packet_conversion!(mqtt_format::v3::packet::MUnsuback);
impl_sub_packet_conversion!(mqtt_format::v3::packet::MPingreq);
impl_sub_packet_conversion!(mqtt_format::v3::packet::MPingresp);
impl_sub_packet_conversion!(mqtt_format::v3::packet::MDisconnect);

impl<P> MqttSubPacket<P>
where
    P: for<'a> yoke::Yokeable<'a>,
    P: Clone,
{
    pub fn from_packet(packet: MqttPacket) -> Option<MqttSubPacket<P>>
    where
        MqttPacket: IntoMqttSubPacket<P>,
    {
        packet.into_mqtt_sub_packet()
    }
}