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

use crate::protocol::len_len;
use crate::protocol::packet::write_remaining_length;
use bytes::{BufMut, Bytes, BytesMut};

/// Subscription packet
#[derive(Clone, Debug, PartialEq, Eq)]
pub enum Unsubscribe {
    V4 {
        packet_id: u16,
        payload: Bytes,
    },
    V5 {
        packet_id: u16,
        properties: Bytes,
        filters: Bytes,
    },
}

impl Unsubscribe {
    pub fn set_packet_id(&mut self, new_packet_id: u16) {
        match self {
            Unsubscribe::V4 { packet_id, .. } => *packet_id = new_packet_id,
            Unsubscribe::V5 { packet_id, .. } => *packet_id = new_packet_id,
        }
    }
    pub fn packet_id(&self) -> u16 {
        match self {
            Unsubscribe::V4 { packet_id, .. } => *packet_id,
            Unsubscribe::V5 { packet_id, .. } => *packet_id,
        }
    }
    pub fn write(&self, buffer: &mut BytesMut) -> usize {
        match self {
            Self::V4 {
                packet_id,
                payload: filters,
            } => {
                // write packet type
                buffer.put_u8(0xa2);
                // write remaining length
                let remaining_len = filters.len() + 2;
                let remaining_len_bytes = write_remaining_length(buffer, remaining_len);
                // write packet id
                buffer.put_u16(*packet_id);
                buffer.extend_from_slice(filters.as_ref());
                1 + remaining_len_bytes + remaining_len
            }
            Self::V5 {
                packet_id,
                properties,
                filters,
            } => {
                buffer.put_u8(0xa2);
                let properties_len = len_len(properties.len());
                let remaining_len = 2 + properties_len + properties.len() + filters.len();
                let remaining_len_bytes = write_remaining_length(buffer, remaining_len);

                buffer.put_u16(*packet_id);
                let _properties_len_bytes = write_remaining_length(buffer, properties.len());
                if properties.len() > 0 {
                    buffer.extend_from_slice(properties.as_ref())
                }
                buffer.extend_from_slice(filters.as_ref());
                1 + remaining_len + remaining_len_bytes
            }
        }
    }
}

#[derive(Clone, Debug, PartialEq, Eq)]
pub struct Filter {
    pub path: String,
}