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
use std::io::Read;
use crate::utils::result::{VentedError, VentedResult};
use byteorder::{BigEndian, ByteOrder, ReadBytesExt};
use serde::de::DeserializeOwned;
use serde::{Deserialize, Serialize};
pub trait GenericEvent {}
#[cfg(test)]
mod tests;
#[derive(Clone, Serialize, Deserialize)]
pub struct EmptyPayload {}
#[derive(Clone, Debug, Serialize, Deserialize)]
pub struct Event {
pub name: String,
pub payload: Vec<u8>,
pub origin: Option<String>,
}
impl Event {
pub fn new<S: ToString>(name: S) -> Self {
Self {
name: name.to_string(),
payload: Vec::with_capacity(0),
origin: None,
}
}
}
impl Event {
pub fn with_payload<T: Serialize, S: ToString>(name: S, payload: &T) -> Self {
let payload = rmp_serde::encode::to_vec(payload).unwrap();
Self {
name: name.to_string(),
payload,
origin: None,
}
}
pub fn as_bytes(&mut self) -> Vec<u8> {
let mut name_raw = self.name.as_bytes().to_vec();
let name_length = name_raw.len();
let mut name_length_raw = [0u8; 2];
BigEndian::write_u16(&mut name_length_raw, name_length as u16);
let payload_length = self.payload.len();
let mut payload_length_raw = [0u8; 8];
BigEndian::write_u64(&mut payload_length_raw, payload_length as u64);
let mut data = Vec::new();
data.append(&mut name_length_raw.to_vec());
data.append(&mut name_raw);
data.append(&mut payload_length_raw.to_vec());
data.append(&mut self.payload);
data
}
pub fn from_bytes<R: Read>(bytes: &mut R) -> VentedResult<Self> {
let name_length = bytes.read_u16::<BigEndian>()?;
let mut name_buf = vec![0u8; name_length as usize];
bytes.read_exact(&mut name_buf)?;
let event_name = String::from_utf8(name_buf).map_err(|_| VentedError::NameDecodingError)?;
let payload_length = bytes.read_u64::<BigEndian>()?;
let mut payload = vec![0u8; payload_length as usize];
bytes.read_exact(&mut payload)?;
Ok(Self {
name: event_name,
payload,
origin: None,
})
}
pub fn get_payload<T: DeserializeOwned>(&self) -> VentedResult<T> {
let payload = rmp_serde::decode::from_read(&self.payload[..])?;
Ok(payload)
}
}