poster 0.3.1

MQTTv5 client library written in Rust.
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

use crate::core::{base_types::UTF8StringPair, properties::UserProperty};
use core::{fmt, str};

/// Map collection for reading user properties as key-value pairs from packets.
#[derive(Clone, Default)]
pub struct UserProperties {
    map: Vec<UTF8StringPair>,
}

impl From<Vec<UTF8StringPair>> for UserProperties {
    fn from(val: Vec<UTF8StringPair>) -> Self {
        Self { map: val }
    }
}

impl From<Vec<UserProperty>> for UserProperties {
    fn from(val: Vec<UserProperty>) -> Self {
        Self {
            map: val.into_iter().map(UTF8StringPair::from).collect(),
        }
    }
}

impl UserProperties {
    pub(crate) fn new() -> Self {
        Self { map: Vec::new() }
    }

    /// Returns a number of key-value pairs in the container.
    pub fn len(&self) -> usize {
        self.map.len()
    }

    /// Returns `true` if the container is empty.
    pub fn is_empty(&self) -> bool {
        self.map.is_empty()
    }

    /// Returns `true` if the container contains `at least one` element with the given key.
    pub fn contains_key(&self, key: &str) -> bool {
        self.map
            .iter()
            .any(|pair| str::from_utf8(&pair.0).unwrap() == key)
    }

    /// Returns an iterator to the values under the given key.
    pub fn get<'a>(&'a self, key: &'a str) -> impl Iterator<Item = &'a str> {
        self.map
            .iter()
            .filter(move |&pair| str::from_utf8(&pair.0).unwrap() == key)
            .map(|pair| str::from_utf8(&pair.1).unwrap())
    }

    /// Returns an iterator which iterates over the keys. Note that it can contain duplicates.
    pub fn keys(&self) -> impl Iterator<Item = &str> {
        self.map.iter().map(|pair| str::from_utf8(&pair.0).unwrap())
    }

    /// Returns an iterator which iterates over the keys.
    pub fn values(&self) -> impl Iterator<Item = &str> {
        self.map.iter().map(|pair| str::from_utf8(&pair.1).unwrap())
    }

    /// Returns an iterator which iterates over key-value tuples.
    pub fn iter(&self) -> impl Iterator<Item = (&str, &str)> {
        self.map.iter().map(|pair| {
            (
                str::from_utf8(&pair.0).unwrap(),
                str::from_utf8(&pair.1).unwrap(),
            )
        })
    }

    pub(crate) fn push(&mut self, val: UserProperty) {
        self.map.push(UTF8StringPair::from(val));
    }
}

impl fmt::Debug for UserProperties {
    fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
        let mut dbg = f.debug_struct("UserProperties");

        for (key, value) in self.iter() {
            dbg.field(key, &value);
        }

        dbg.finish()
    }
}

#[cfg(test)]
mod test {
    use bytes::Bytes;

    use super::*;

    #[test]
    fn size() {
        let properties = UserProperties::new();
        assert!(properties.is_empty());
        assert_eq!(properties.len(), 0);
    }

    #[test]
    fn access() {
        let mut properties = UserProperties::new();
        properties.push(UserProperty::from(UTF8StringPair(
            Bytes::from_static("key0".as_bytes()),
            Bytes::from_static("val0".as_bytes()),
        )));
        properties.push(UserProperty::from(UTF8StringPair(
            Bytes::from_static("key1".as_bytes()),
            Bytes::from_static("val1".as_bytes()),
        )));
        properties.push(UserProperty::from(UTF8StringPair(
            Bytes::from_static("key1".as_bytes()),
            Bytes::from_static("val2".as_bytes()),
        )));

        assert!(!properties.is_empty());
        assert_eq!(properties.len(), 3);

        assert!(properties.contains_key("key0"));
        assert!(properties.contains_key("key1"));
        assert_eq!(properties.get("key0").collect::<Vec<&str>>(), ["val0"]);
        assert_eq!(
            properties.get("key1").collect::<Vec<&str>>(),
            ["val1", "val2"]
        );
        assert_eq!(
            properties.keys().collect::<Vec<&str>>(),
            ["key0", "key1", "key1"]
        );
        assert_eq!(
            properties.values().collect::<Vec<&str>>(),
            ["val0", "val1", "val2"]
        );
        assert_eq!(
            properties.iter().collect::<Vec<(&str, &str)>>(),
            [("key0", "val0"), ("key1", "val1"), ("key1", "val2")]
        );
    }
}