1
2pub trait ToDataMessage {
3 fn to_data_message(&self) -> DataMessage;
4}
5
6pub trait FromDataMessage {
7 fn from_data_message(dm: DataMessage) -> Option<Self> where Self: Sized;
8}
9
10#[derive(Clone)]
11pub enum DataMessage {
12 Bool(bool),
13 U8(u8),
14 U16(u16),
15 U32(u32),
16 F32(f32),
17 FVec2(f32, f32),
18 FVec3(f32, f32, f32),
19 FVec4(f32, f32, f32, f32),
20 F64(f64),
21 List(Vec<Box<DataMessage>>),
22 Str(String),
23}
24
25pub trait CharVecCompatible {
26 fn to_vec8(&self) -> Vec<u8>;
27 fn from_vec8(v: Vec<u8>) -> Option<Self> where Self: Sized;
28}
29
30impl CharVecCompatible for DataMessage {
31 fn to_vec8(&self) -> Vec<u8> {
32 match self {
33 DataMessage::Bool(b) => {
34 let data_vec = vec![ if *b { 1u8 } else { 0u8 } ];
35 [ 0u8.to_be_bytes().to_vec(), data_vec ].concat()
36 },
37
38 DataMessage::U8(u8) => {
39 let data_vec = u8.to_be_bytes().to_vec();
40 [ 1u8.to_be_bytes().to_vec(), data_vec ].concat()
41 },
42
43 DataMessage::U16(u16) => {
44 let data_vec = u16.to_be_bytes().to_vec();
45 [ 2u8.to_be_bytes().to_vec(), data_vec ].concat()
46 },
47
48 DataMessage::U32(u32) => {
49 let data_vec = u32.to_be_bytes().to_vec();
50 [ 3u8.to_be_bytes().to_vec(), data_vec ].concat()
51 },
52
53 DataMessage::F32(f32) => {
54 let data_vec = f32.to_be_bytes().to_vec();
55 [ 4u8.to_be_bytes().to_vec(), data_vec ].concat()
56 },
57
58 DataMessage::FVec2(a, b) => {
59 let a_vec = a.to_be_bytes().to_vec();
60 let b_vec = b.to_be_bytes().to_vec();
61 [ 5u8.to_be_bytes().to_vec(), a_vec, b_vec ].concat()
62 }
63
64 DataMessage::FVec3(a, b, c) => {
65 let a_vec = a.to_be_bytes().to_vec();
66 let b_vec = b.to_be_bytes().to_vec();
67 let c_vec = c.to_be_bytes().to_vec();
68 [ 6u8.to_be_bytes().to_vec(), a_vec, b_vec, c_vec ].concat()
69 }
70
71 DataMessage::FVec4(a, b, c, d) => {
72 let a_vec = a.to_be_bytes().to_vec();
73 let b_vec = b.to_be_bytes().to_vec();
74 let c_vec = c.to_be_bytes().to_vec();
75 let d_vec = d.to_be_bytes().to_vec();
76 [ 7u8.to_be_bytes().to_vec(), a_vec, b_vec, c_vec, d_vec ].concat()
77 }
78
79 DataMessage::F64(d) => {
80 let d_vec = d.to_be_bytes().to_vec();
81 [ 8u8.to_be_bytes().to_vec(), d_vec ].concat()
82 },
83
84 DataMessage::List(data) => {
85 let size_vec = (data.len() as u32).to_be_bytes().to_vec();
86 let data_vec: Vec<u8> = data.iter().map(|d| d.to_vec8()).flatten().collect();
87 [ 9u8.to_be_bytes().to_vec(), size_vec, data_vec ].concat()
88 },
89
90 DataMessage::Str(data) => {
91 let data_vec = data.as_bytes().to_vec();
92 let size_vec = (data_vec.len() as u32).to_be_bytes().to_vec();
93 [ 10u8.to_be_bytes().to_vec(), size_vec, data_vec ].concat()
94 }
95 }
96 }
97
98 fn from_vec8(v: Vec<u8>) -> Option<DataMessage> {
99 fn get_static_data_message_size(m: u8) -> usize {
100 1 + match m {
101 0 => 1,
102 1 => 1,
103 2 => 2,
104 3 => 4,
105 4 => 4,
106 5 => 8,
107 6 => 12,
108 7 => 16,
109 8 => 8,
110 9 => 4,
111 10 => 4,
112 _ => 0,
113 }
114 }
115
116 fn from_vec8_internal(v: &Vec<u8>, start: &mut usize, depth: u8) -> Option<DataMessage> {
117 println!("FROM {:?} {} {}", v, start, depth);
118 let mut index = *start;
119
120 let cursor = v[index];
121 println!("out Cursor: {}", cursor);
122
123 index += 1;
124 *start += get_static_data_message_size(cursor);
125
126 match cursor {
127 0 => Some(DataMessage::Bool(if v[index] == 0 { false } else { true })),
128 1 => Some(DataMessage::U8(v[index])),
129 2 => Some(DataMessage::U16(u16::from_be_bytes([v[index], v[index + 1]]))),
130 3 => Some(DataMessage::U32(u32::from_be_bytes([v[index], v[index + 1], v[index + 2], v[index + 3]]))),
131 4 => Some(DataMessage::F32(f32::from_be_bytes([v[index], v[index + 1], v[index + 2], v[index + 3]]))),
132 5 => Some(DataMessage::FVec2(
133 f32::from_be_bytes([v[index + 0], v[index + 1], v[index + 2], v[index + 3]]),
134 f32::from_be_bytes([v[index + 4], v[index + 5], v[index + 6], v[index + 7]]))),
135 6 => Some(DataMessage::FVec3(
136 f32::from_be_bytes([v[index + 0], v[index + 1], v[index + 2], v[index + 3]]),
137 f32::from_be_bytes([v[index + 4], v[index + 5], v[index + 6], v[index + 7]]),
138 f32::from_be_bytes([v[index + 8], v[index + 9], v[index + 10], v[index + 11]]))),
139 7 => Some(DataMessage::FVec4(
140 f32::from_be_bytes([v[index + 0], v[index + 1], v[index + 2], v[index + 3]]),
141 f32::from_be_bytes([v[index + 4], v[index + 5], v[index + 6], v[index + 7]]),
142 f32::from_be_bytes([v[index + 8], v[index + 9], v[index + 10], v[index + 11]]),
143 f32::from_be_bytes([v[index + 12], v[index + 13], v[index + 14], v[index + 15]]))),
144 8 => Some(DataMessage::F64(
145 f64::from_be_bytes([v[index + 0], v[index + 1], v[index + 2], v[index + 3],
146 v[index + 4], v[index + 5], v[index + 6], v[index + 7]]))),
147
148 9 => {
149 let count = u32::from_be_bytes([v[index], v[index + 1], v[index + 2], v[index + 3]]);
150 let data: Vec<Box<DataMessage>> = (0..count)
151 .map(|_| { Box::new(from_vec8_internal(v, start, depth + 1).expect("List internal failed parsing.")) })
152 .collect();
153 println!("{} == {}", count, data.len());
154 assert_eq!(count as usize, data.len());
155 Some(DataMessage::List(data))
156 },
157
158 10 => {
159 let count = u32::from_be_bytes([v[index], v[index + 1], v[index + 2], v[index + 3]]);
160 if let Ok(str) = std::str::from_utf8(&v[(index + 4)..(index + 4 + count as usize)]) {
161 Some(DataMessage::Str(str.to_string()))
162 } else {
163 None
164 }
165 }
166
167 _ => None
168 }
169 }
170
171 let mut start = 0;
172 from_vec8_internal(&v, &mut start, 0)
173 }
174}
175
176
177impl ToDataMessage for bool {
178 fn to_data_message(&self) -> DataMessage {
179 DataMessage::Bool(*self)
180 }
181}
182
183impl ToDataMessage for u8 {
184 fn to_data_message(&self) -> DataMessage {
185 DataMessage::U8(*self)
186 }
187}
188
189impl ToDataMessage for u16 {
190 fn to_data_message(&self) -> DataMessage {
191 DataMessage::U16(*self)
192 }
193}
194
195impl ToDataMessage for u32 {
196 fn to_data_message(&self) -> DataMessage {
197 DataMessage::U32(*self)
198 }
199}
200
201impl ToDataMessage for f32 {
202 fn to_data_message(&self) -> DataMessage {
203 DataMessage::F32(*self)
204 }
205}
206
207impl ToDataMessage for (f32, f32) {
208 fn to_data_message(&self) -> DataMessage {
209 DataMessage::FVec2(self.0, self.1)
210 }
211}
212
213impl ToDataMessage for (f32, f32, f32) {
214 fn to_data_message(&self) -> DataMessage {
215 DataMessage::FVec3(self.0, self.1, self.2)
216 }
217}
218
219impl ToDataMessage for (f32, f32, f32, f32) {
220 fn to_data_message(&self) -> DataMessage {
221 DataMessage::FVec4(self.0, self.1, self.2, self.3)
222 }
223}
224
225impl ToDataMessage for f64 {
226 fn to_data_message(&self) -> DataMessage {
227 DataMessage::F64(*self)
228 }
229}
230
231impl<T> ToDataMessage for Vec<T> where T: ToDataMessage {
232 fn to_data_message(&self) -> DataMessage {
233 DataMessage::List(self.iter().map(|x| Box::new(x.to_data_message())).collect())
234 }
235}
236
237impl ToDataMessage for String {
238 fn to_data_message(&self) -> DataMessage {
239 DataMessage::Str(self.clone())
240 }
241}
242
243
244impl FromDataMessage for bool {
245 fn from_data_message(dm: DataMessage) -> Option<Self> where Self: Sized {
246 if let DataMessage::Bool(b) = dm { Some(b) } else { None }
247 }
248}
249
250impl FromDataMessage for u8 {
251 fn from_data_message(dm: DataMessage) -> Option<Self> where Self: Sized {
252 if let DataMessage::U8(b) = dm { Some(b) } else { None }
253 }
254}
255
256impl FromDataMessage for u16 {
257 fn from_data_message(dm: DataMessage) -> Option<Self> where Self: Sized {
258 if let DataMessage::U16(b) = dm { Some(b) } else { None }
259 }
260}
261
262impl FromDataMessage for u32 {
263 fn from_data_message(dm: DataMessage) -> Option<Self> where Self: Sized {
264 if let DataMessage::U32(b) = dm { Some(b) } else { None }
265 }
266}
267
268impl FromDataMessage for f32 {
269 fn from_data_message(dm: DataMessage) -> Option<Self> where Self: Sized {
270 if let DataMessage::F32(b) = dm { Some(b) } else { None }
271 }
272}
273
274impl FromDataMessage for (f32, f32) {
275 fn from_data_message(dm: DataMessage) -> Option<Self> where Self: Sized {
276 if let DataMessage::FVec2(a, b) = dm { Some((a, b)) } else { None }
277 }
278}
279
280impl FromDataMessage for (f32, f32, f32) {
281 fn from_data_message(dm: DataMessage) -> Option<Self> where Self: Sized {
282 if let DataMessage::FVec3(a, b, c) = dm { Some((a, b, c)) } else { None }
283 }
284}
285
286impl FromDataMessage for (f32, f32, f32, f32) {
287 fn from_data_message(dm: DataMessage) -> Option<Self> where Self: Sized {
288 if let DataMessage::FVec4(a, b, c, d) = dm { Some((a, b, c, d)) } else { None }
289 }
290}
291
292impl FromDataMessage for f64 {
293 fn from_data_message(dm: DataMessage) -> Option<Self> where Self: Sized {
294 if let DataMessage::F64(b) = dm { Some(b) } else { None }
295 }
296}
297
298impl<T> FromDataMessage for Vec<T> where T: FromDataMessage {
299 fn from_data_message(dm: DataMessage) -> Option<Self> where Self: Sized {
300 if let DataMessage::List(v) = dm {
301 Some(v.iter().map(|x| T::from_data_message(*x.clone()).unwrap()).collect())
302 } else { None }
303 }
304}
305
306impl FromDataMessage for String {
307 fn from_data_message(dm: DataMessage) -> Option<Self> where Self: Sized {
308 if let DataMessage::Str(s) = dm { Some(s) } else { None }
309 }
310}