spyne_encoding/serialization/
binary.rs1use crate::serialization::{deserialize::{Deserialize, Deserializer}, serialize::{Serialize, Serializer}};
2
3pub struct BinarySerde {
4 buffer: Vec<u8>,
5 read_index: usize
6}
7
8impl BinarySerde {
9 fn new(buffer: Option<Vec<u8>>) -> Self {
10 Self {
11 buffer: match buffer {
12 Some(buf) => buf,
13 None => Vec::new()
14 },
15 read_index: 0
16 }
17 }
18
19 fn read_inc<const N: usize>(&mut self) -> Result<[u8; N], String> {
20 if self.read_index + N > self.buffer.len() {
21 return Err("BinarySerde: Deserialization out of bounds.".to_string());
22 }
23
24 let slice = self.buffer[self.read_index..self.read_index + N].try_into().unwrap();
25 self.read_index += N;
26 Ok(slice)
27 }
28
29 pub fn serialize<'a, T: Serialize<'a>>(item: &T) -> Result<Vec<u8>, String> {
30 let mut serde = BinarySerde::new(None);
31 item.serialize(&mut serde);
32 Ok(serde.buffer.clone())
33 }
34
35 pub fn deserialize<T: Deserialize>(buffer: Vec<u8>) -> Result<T, String> {
36 let mut serde = BinarySerde::new(Some(buffer));
37 Ok(T::deserialize(&mut serde)?)
38 }
39}
40
41impl<'a> Serializer<'a> for BinarySerde {
42 fn write_u8(&mut self, n: u8) {
43 self.buffer.push(n);
44 }
45
46 fn write_u16(&mut self, n: u16) {
47 self.buffer.extend_from_slice(&n.to_le_bytes());
48 }
49
50 fn write_u32(&mut self, n: u32) {
51 self.buffer.extend_from_slice(&n.to_le_bytes());
52 }
53
54 fn write_u64(&mut self, n: u64) {
55 self.buffer.extend_from_slice(&n.to_le_bytes());
56 }
57
58 fn write_u128(&mut self, n: u128) {
59 self.buffer.extend_from_slice(&n.to_le_bytes());
60 }
61
62 fn write_i8(&mut self, n: i8) {
63 self.buffer.extend_from_slice(&n.to_le_bytes());
64 }
65
66 fn write_i16(&mut self, n: i16) {
67 self.buffer.extend_from_slice(&n.to_le_bytes());
68 }
69
70 fn write_i32(&mut self, n: i32) {
71 self.buffer.extend_from_slice(&n.to_le_bytes());
72 }
73
74 fn write_i64(&mut self, n: i64) {
75 self.buffer.extend_from_slice(&n.to_le_bytes());
76 }
77
78 fn write_i128(&mut self, n: i128) {
79 self.buffer.extend_from_slice(&n.to_le_bytes());
80 }
81
82 fn write_f32(&mut self, n: f32) {
83 self.buffer.extend_from_slice(&n.to_le_bytes());
84 }
85
86 fn write_f64(&mut self, n: f64) {
87 self.buffer.extend_from_slice(&n.to_le_bytes());
88 }
89
90 fn write_bool(&mut self, b: bool) {
91 self.buffer.extend_from_slice(&(b as u8).to_le_bytes());
92 }
93
94 fn write_bytes(&mut self, bytes: &[u8]) {
95 self.buffer.extend_from_slice(&(bytes.len() as u64).to_le_bytes());
96 self.buffer.extend_from_slice(bytes);
97 }
98
99 fn write_string(&mut self, s: &str) {
100 self.buffer.extend_from_slice(&(s.len() as u64).to_le_bytes());
101 self.buffer.extend_from_slice(s.as_bytes());
102 }
103
104 fn write_seq<F>(&mut self, len: usize, f: F)
105 where F: FnOnce(&mut Self) {
106 self.buffer.extend_from_slice(&(len as u64).to_le_bytes());
107 f(self)
108 }
109
110 fn write_map<F>(&mut self, len: usize, f: F)
111 where F: FnOnce(&mut Self) {
112 self.buffer.extend_from_slice(&(len as u64).to_le_bytes());
113 f(self)
114 }
115
116 fn write_struct<F>(&mut self, _name: &str, _fields: &[&str], f: F)
117 where F: FnOnce(&mut Self) {
118 f(self)
119 }
120
121 fn write_tuple<F>(&mut self, _len: usize, f: F)
122 where F: FnOnce(&mut Self) {
123 f(self)
124 }
125
126 fn write_enum<F>(&mut self, _enum_name: &str, variant_index: u32, _variant_name: &'a [&'a str], f: F)
127 where F: FnOnce(&mut Self) {
128 self.buffer.extend_from_slice(&variant_index.to_le_bytes());
129 f(self)
130 }
131}
132
133impl Deserializer for BinarySerde {
134 fn read_u8(&mut self) -> Result<u8, String> {
135 Ok(u8::from_le_bytes(self.read_inc::<1>()?))
136 }
137
138 fn read_u16(&mut self) -> Result<u16, String> {
139 Ok(u16::from_le_bytes(self.read_inc::<2>()?))
140 }
141
142 fn read_u32(&mut self) -> Result<u32, String> {
143 Ok(u32::from_le_bytes(self.read_inc::<4>()?))
144 }
145
146 fn read_u64(&mut self) -> Result<u64, String> {
147 Ok(u64::from_le_bytes(self.read_inc::<8>()?))
148 }
149
150 fn read_u128(&mut self) -> Result<u128, String> {
151 Ok(u128::from_le_bytes(self.read_inc::<16>()?))
152 }
153
154 fn read_i8(&mut self) -> Result<i8, String> {
155 Ok(i8::from_le_bytes(self.read_inc::<1>()?))
156 }
157
158 fn read_i16(&mut self) -> Result<i16, String> {
159 Ok(i16::from_le_bytes(self.read_inc::<2>()?))
160 }
161
162 fn read_i32(&mut self) -> Result<i32, String> {
163 Ok(i32::from_le_bytes(self.read_inc::<4>()?))
164 }
165
166 fn read_i64(&mut self) -> Result<i64, String> {
167 Ok(i64::from_le_bytes(self.read_inc::<8>()?))
168 }
169
170 fn read_i128(&mut self) -> Result<i128, String> {
171 Ok(i128::from_le_bytes(self.read_inc::<16>()?))
172 }
173
174 fn read_f32(&mut self) -> Result<f32, String> {
175 Ok(f32::from_le_bytes(self.read_inc::<4>()?))
176 }
177
178 fn read_f64(&mut self) -> Result<f64, String> {
179 Ok(f64::from_le_bytes(self.read_inc::<8>()?))
180 }
181
182 fn read_bool(&mut self) -> Result<bool, String> {
183 Ok(u8::from_le_bytes(self.read_inc::<1>()?) != 0)
184 }
185
186 fn read_bytes(&mut self) -> Result<Vec<u8>, String> {
187 let len = u64::from_le_bytes(self.read_inc::<8>()?) as usize;
188 if self.read_index + len > self.buffer.len() {
189 return Err("BinarySerde: Buffer underflow while deserializing bytes.".to_string());
190 }
191
192 let vec = self.buffer[self.read_index..self.read_index + len].to_vec();
193 self.read_index += len;
194
195 Ok(vec)
196 }
197
198 fn read_string(&mut self) -> Result<String, String> {
199 let len = u64::from_le_bytes(self.read_inc::<8>()?) as usize;
200 if self.read_index + len > self.buffer.len() {
201 return Err("BinarySerde: Buffer underflow while deserializing String.".to_string());
202 }
203
204 let vec = self.buffer[self.read_index..self.read_index + len].to_vec();
205 self.read_index += len;
206
207 Ok(
208 String::from_utf8(vec)
209 .map_err(|_| "BinarySerde: Invalid UTF-8 characters while deserializing String".to_string())?
210 )
211 }
212
213 fn read_seq<F, T>(&mut self, f: F) -> Result<T, String>
214 where F: FnOnce(&mut Self, usize) -> Result<T, String> {
215 let len = u64::from_le_bytes(self.read_inc::<8>()?) as usize;
216
217 Ok(f(self, len)?)
218 }
219
220 fn read_map<F, T>(&mut self, f: F) -> Result<T, String>
221 where F: FnOnce(&mut Self, usize) -> Result<T, String> {
222 let len = u64::from_le_bytes(self.read_inc::<8>()?) as usize;
223
224 Ok(f(self, len)?)
225 }
226
227 fn read_tuple<F, T>(&mut self, _len: usize, f: F) -> Result<T, String>
228 where F: FnOnce(&mut Self) -> Result<T, String> {
229 f(self)
230 }
231
232 fn read_struct<F, T>(&mut self, _name: &str, _fields: &[&str], f: F) -> Result<T, String>
233 where F: FnOnce(&mut Self) -> Result<T, String> {
234 f(self)
235 }
236
237 fn read_enum<F, T>(&mut self, _enum_name: &str, _variants: &[&str], f: F) -> Result<T, String>
238 where F: FnOnce(&mut Self, u32) -> Result<T, String> {
239 let var_index = u32::from_le_bytes(self.read_inc::<4>()?);
240 f(self, var_index)
241 }
242}
243
244#[cfg(test)]
245mod test {
246 use super::*;
247
248 #[derive(Debug, PartialEq)]
249 struct Widget {
250 id: u64,
251 name: String,
252 values: Vec<i32>
253 }
254
255 impl<'a> Serialize<'a> for Widget {
256 fn serialize(&self, serializer: &mut impl Serializer<'a>) {
257 serializer.write_u64(self.id);
258 serializer.write_string(&self.name);
259 serializer.write_seq(self.values.len(), |enc| {
260 for item in &self.values {
261 item.serialize(enc);
262 }
263 });
264 }
265 }
266
267 impl Deserialize for Widget {
268 fn deserialize(deserializer: &mut impl Deserializer) -> Result<Self, String> {
269 let id = u64::deserialize(deserializer)?;
270 let name = String::deserialize(deserializer)?;
271 let values = Vec::deserialize(deserializer)?;
272 Ok(Widget { id, name, values })
273 }
274 }
275
276 #[test]
277 fn test_serde() -> Result<(), String>{
278 let original = Widget {
279 id: 101,
280 name: "Wid".to_string(),
281 values: vec![5, 10, -2]
282 };
283
284 let serialized = BinarySerde::serialize(&original)?;
285 let new = BinarySerde::deserialize(serialized).unwrap();
286
287 assert_eq!(original, new);
288
289 Ok(())
290 }
291}