tinymqtt 0.1.3

A very tiny no-std MQTT client, mainly for embedded systems
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
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149

use super::flags::Flags;

pub struct MqttMessageWriter<'a> {
    buffer: &'a mut [u8],
    cursor: usize,
}

impl<'a> MqttMessageWriter<'a> {
    pub fn new(buffer: &'a mut [u8]) -> Self {
        Self { buffer, cursor: 0 }
    }

    pub fn write_u8(&mut self, value: u8) {
        self.buffer[self.cursor] = value;
        self.cursor += 1;
    }

    pub fn write_flags(&mut self, value: Flags) {
        self.write_u8(value.value);
    }

    pub fn write_u16(&mut self, value: u16) {
        self.buffer[self.cursor] = (value >> 8) as u8;
        self.buffer[self.cursor + 1] = value as u8;
        self.cursor += 2;
    }

    pub fn write_string(&mut self, value: &str) {
        self.write_u16(value.len() as u16);
        for byte in value.bytes() {
            self.buffer[self.cursor] = byte;
            self.cursor += 1;
        }
    }

    pub fn write_bytes(&mut self, value: &[u8]) {
        self.write_u16(value.len() as u16);
        self.write_bytes_raw(value);
    }

    pub fn write_bytes_raw(&mut self, value: &[u8]) {
        for byte in value {
            self.buffer[self.cursor] = *byte;
            self.cursor += 1;
        }
    }

    pub fn write_variable_int(&mut self, mut value: u32) {
        loop {
            // Successively take the last 7 bits, check if anything remaining (i.e. > 0),
            // and repeat
            let mut byte = (value & 0x7F) as u8;
            value >>= 7;
            if value > 0 {
                byte |= 0x80;
            }
            self.buffer[self.cursor] = byte;
            self.cursor += 1;
            if value == 0 {
                break;
            }
        }
    }

    pub fn len(&self) -> usize {
        self.cursor
    }
}

pub struct MqttMessageReader<'a> {
    buffer: &'a [u8],
    cursor: usize,
    mark: usize,
}

impl<'a> MqttMessageReader<'a> {
    pub fn new(buffer: &'a [u8]) -> Self {
        Self {
            buffer,
            cursor: 0,
            mark: 0,
        }
    }

    pub fn read_u8(&mut self) -> u8 {
        let value = self.buffer[self.cursor];
        self.cursor += 1;
        value
    }

    pub fn read_u16(&mut self) -> u16 {
        let value = ((self.buffer[self.cursor] as u16) << 8) | self.buffer[self.cursor + 1] as u16;
        self.cursor += 2;
        value
    }

    pub fn read_string(&mut self) -> &'a str {
        let length = self.read_u16() as usize;
        let start = self.cursor;
        self.cursor += length;
        core::str::from_utf8(&self.buffer[start..self.cursor]).unwrap()
    }

    pub fn read_bytes(&mut self) -> &'a [u8] {
        let length = self.read_u16() as usize;
        self.read_bytes_raw(length)
    }

    pub fn read_bytes_raw(&mut self, length: usize) -> &'a [u8] {
        let start = self.cursor;
        self.cursor += length;
        &self.buffer[start..self.cursor]
    }

    pub fn read_variable_int(&mut self) -> u32 {
        let mut value = 0;
        let mut shift = 0;
        loop {
            let byte = self.buffer[self.cursor];
            self.cursor += 1;
            value |= ((byte & 0x7F) as u32) << shift;
            shift += 7;
            if byte & 0x80 == 0 {
                break;
            }
        }
        value
    }

    pub fn remaining(&self) -> usize {
        self.buffer.len() - self.cursor
    }

    pub fn skip(&mut self, length: usize) {
        self.cursor += length;
    }

    pub fn mark(&mut self) {
        self.mark = self.cursor;
    }

    pub fn skip_to(&mut self, position: usize) {
        self.cursor = self.mark + position;
    }

    pub fn distance_from_mark(&self) -> usize {
        self.cursor - self.mark
    }
}