serde_binary_adv/serde_binary_adv/stream/
ser.rs

1//! Serialize a Rust structure into a binary data stream.
2
3use std::io::Write;
4
5use super::super::Result;
6use crate::{
7	BinaryError,
8	serde_binary_adv::common::{
9		compress_usize,
10		flags::{self, NONUNIT_VARIANT, STRUCT_VARIANT, UNIT_VARIANT},
11	},
12};
13use num::traits::ToBytes;
14use serde::{Serialize, ser};
15
16/// A structure for serializing Rust values into binary.
17pub struct Serializer<'se> {
18	output: &'se mut dyn Write,
19	big_endian: bool,
20	unsized_seq: bool,
21}
22
23impl<'se> Serializer<'se> {
24	/// Converts a Rust value into a binary representation and returns a `Vec<u8>` of the bytes
25	pub fn write_bytes<T>(output: &'se mut impl Write, value: &T, big_endian: bool) -> Result<()>
26	where
27		T: Serialize,
28	{
29		let mut serializer = Self::new(output, big_endian);
30		value.serialize(&mut serializer)?;
31		Ok(())
32	}
33
34	/// Creates a new binary Serializer
35	pub fn new(output: &'se mut impl Write, big_endian: bool) -> Self {
36		Self {
37			output,
38			big_endian,
39			unsized_seq: false,
40		}
41	}
42
43	fn write(&mut self, data: &Vec<u8>) {
44		self.output.write(data.as_slice()).unwrap();
45	}
46
47	fn serialize_num<T: ToBytes>(self: &mut Self, v: T) -> Result<()> {
48		if self.big_endian {
49			self.write(&v.to_be_bytes().as_mut().to_vec());
50		} else {
51			self.write(&v.to_le_bytes().as_mut().to_vec());
52		}
53		Ok(())
54	}
55
56	fn serialize_vec<T: ToBytes>(self: &mut Self, v: Vec<T>) -> Result<()> {
57		for item in v {
58			self.serialize_num(item)?;
59		}
60		Ok(())
61	}
62
63	fn serialize_usize(&mut self, v: usize) -> Result<()> {
64		self.serialize_vec(compress_usize(v))?;
65		Ok(())
66	}
67}
68
69impl<'se> ser::Serializer for &mut Serializer<'se> {
70	type Ok = ();
71	type Error = BinaryError;
72
73	type SerializeSeq = Self;
74	type SerializeTuple = Self;
75	type SerializeTupleStruct = Self;
76	type SerializeTupleVariant = Self;
77	type SerializeMap = Self;
78	type SerializeStruct = Self;
79	type SerializeStructVariant = Self;
80
81	fn serialize_bool(self, v: bool) -> Result<Self::Ok> {
82		self.serialize_u8(if v { 1 } else { 0 })
83	}
84
85	fn serialize_u8(self, v: u8) -> Result<Self::Ok> {
86		self.serialize_num(v)
87	}
88
89	fn serialize_u16(self, v: u16) -> Result<Self::Ok> {
90		self.serialize_num(v)
91	}
92
93	fn serialize_u32(self, v: u32) -> Result<Self::Ok> {
94		self.serialize_num(v)
95	}
96
97	fn serialize_u64(self, v: u64) -> Result<Self::Ok> {
98		self.serialize_num(v)
99	}
100
101	fn serialize_u128(self, v: u128) -> Result<Self::Ok> {
102		self.serialize_num(v)
103	}
104
105	fn serialize_i8(self, v: i8) -> Result<Self::Ok> {
106		self.serialize_num(v)
107	}
108
109	fn serialize_i16(self, v: i16) -> Result<Self::Ok> {
110		self.serialize_num(v)
111	}
112
113	fn serialize_i32(self, v: i32) -> Result<Self::Ok> {
114		self.serialize_num(v)
115	}
116
117	fn serialize_i64(self, v: i64) -> Result<Self::Ok> {
118		self.serialize_num(v)
119	}
120
121	fn serialize_i128(self, v: i128) -> Result<Self::Ok> {
122		self.serialize_num(v)
123	}
124
125	fn serialize_f32(self, v: f32) -> Result<Self::Ok> {
126		self.serialize_num(v)
127	}
128
129	fn serialize_f64(self, v: f64) -> Result<Self::Ok> {
130		self.serialize_num(v)
131	}
132
133	fn serialize_char(self, v: char) -> Result<Self::Ok> {
134		let mut buf: [u8; 4] = [0, 0, 0, 0];
135		self.serialize_vec(v.encode_utf8(&mut buf).as_bytes().to_vec())
136	}
137
138	fn serialize_str(self, v: &str) -> Result<Self::Ok> {
139		self.serialize_usize(v.bytes().len()).unwrap();
140		self.serialize_vec(v.as_bytes().to_vec())
141	}
142
143	fn serialize_bytes(self, v: &[u8]) -> Result<Self::Ok> {
144		self.serialize_vec(v.to_vec())
145	}
146
147	fn serialize_none(self) -> Result<Self::Ok> {
148		self.serialize_u8(flags::NONE)
149	}
150
151	fn serialize_some<T>(self, value: &T) -> Result<Self::Ok>
152	where
153		T: ?Sized + ser::Serialize,
154	{
155		self.serialize_u8(flags::SOME).unwrap();
156		value.serialize(self)
157	}
158
159	fn serialize_unit(self) -> Result<Self::Ok> {
160		Ok(())
161	}
162
163	fn serialize_unit_struct(self, _name: &'static str) -> Result<Self::Ok> {
164		Ok(())
165	}
166
167	fn serialize_unit_variant(
168		self,
169		_name: &'static str,
170		variant_index: u32,
171		_variant: &'static str,
172	) -> Result<Self::Ok> {
173		UNIT_VARIANT.serialize(&mut *self).unwrap();
174		variant_index.serialize(&mut *self)
175	}
176
177	fn serialize_newtype_struct<T>(self, _name: &'static str, value: &T) -> Result<Self::Ok>
178	where
179		T: ?Sized + ser::Serialize,
180	{
181		value.serialize(self)
182	}
183
184	fn serialize_newtype_variant<T>(
185		self,
186		_name: &'static str,
187		variant_index: u32,
188		_variant: &'static str,
189		value: &T,
190	) -> Result<Self::Ok>
191	where
192		T: ?Sized + ser::Serialize,
193	{
194		NONUNIT_VARIANT.serialize(&mut *self).unwrap();
195		variant_index.serialize(&mut *self).unwrap();
196		value.serialize(self)
197	}
198
199	fn serialize_seq(self, len: Option<usize>) -> Result<Self::SerializeSeq> {
200		match len {
201			Some(n) => {
202				self.serialize_usize(n).unwrap();
203				self.unsized_seq = false;
204			}
205			None => unimplemented!(),
206		}
207		Ok(self)
208	}
209
210	fn serialize_tuple(self, len: usize) -> Result<Self::SerializeTuple> {
211		self.serialize_seq(Some(len))
212	}
213
214	fn serialize_tuple_struct(
215		self,
216		_name: &'static str,
217		len: usize,
218	) -> Result<Self::SerializeTupleStruct> {
219		self.serialize_seq(Some(len))
220	}
221
222	fn serialize_tuple_variant(
223		self,
224		_name: &'static str,
225		variant_index: u32,
226		_variant: &'static str,
227		len: usize,
228	) -> Result<Self::SerializeTupleVariant> {
229		NONUNIT_VARIANT.serialize(&mut *self).unwrap();
230		variant_index.serialize(&mut *self).unwrap();
231		self.serialize_usize(len).unwrap();
232		Ok(self)
233	}
234
235	fn serialize_map(self, len: Option<usize>) -> Result<Self::SerializeMap> {
236		match len {
237			Some(n) => {
238				self.serialize_vec(compress_usize(n)).unwrap();
239				Ok(self)
240			}
241			// Serializing maps of unknown length to binary is difficult, since any value that
242			// can be used to mark the end of the sequence can also be a member
243			None => unimplemented!(),
244		}
245	}
246
247	fn serialize_struct(self, _name: &'static str, len: usize) -> Result<Self::SerializeStruct> {
248		self.serialize_usize(len).unwrap();
249		Ok(self)
250	}
251
252	fn serialize_struct_variant(
253		self,
254		_name: &'static str,
255		variant_index: u32,
256		_variant: &'static str,
257		len: usize,
258	) -> Result<Self::SerializeStructVariant> {
259		STRUCT_VARIANT.serialize(&mut *self).unwrap();
260		variant_index.serialize(&mut *self).unwrap();
261		self.serialize_usize(len).unwrap();
262		Ok(self)
263	}
264}
265
266impl<'se> ser::SerializeSeq for &mut Serializer<'se> {
267	type Ok = ();
268	type Error = BinaryError;
269
270	fn serialize_element<T>(&mut self, value: &T) -> Result<()>
271	where
272		T: ?Sized + Serialize,
273	{
274		value.serialize(&mut **self)
275	}
276
277	// Close the sequence.
278	fn end(self) -> Result<()> {
279		Ok(())
280	}
281}
282
283impl<'se> ser::SerializeTuple for &mut Serializer<'se> {
284	type Ok = ();
285	type Error = BinaryError;
286
287	fn serialize_element<T>(&mut self, value: &T) -> Result<()>
288	where
289		T: ?Sized + Serialize,
290	{
291		value.serialize(&mut **self)
292	}
293
294	fn end(self) -> Result<()> {
295		Ok(())
296	}
297}
298
299impl<'se> ser::SerializeTupleStruct for &mut Serializer<'se> {
300	type Ok = ();
301	type Error = BinaryError;
302
303	fn serialize_field<T>(&mut self, value: &T) -> Result<()>
304	where
305		T: ?Sized + Serialize,
306	{
307		value.serialize(&mut **self)
308	}
309
310	fn end(self) -> Result<()> {
311		Ok(())
312	}
313}
314
315impl<'se> ser::SerializeTupleVariant for &mut Serializer<'se> {
316	type Ok = ();
317	type Error = BinaryError;
318
319	fn serialize_field<T>(&mut self, value: &T) -> Result<()>
320	where
321		T: ?Sized + Serialize,
322	{
323		value.serialize(&mut **self)
324	}
325
326	fn end(self) -> Result<()> {
327		Ok(())
328	}
329}
330
331impl<'se> ser::SerializeMap for &mut Serializer<'se> {
332	type Ok = ();
333	type Error = BinaryError;
334
335	fn serialize_key<T>(&mut self, key: &T) -> Result<()>
336	where
337		T: ?Sized + Serialize,
338	{
339		key.serialize(&mut **self)
340	}
341
342	fn serialize_value<T>(&mut self, value: &T) -> Result<()>
343	where
344		T: ?Sized + Serialize,
345	{
346		value.serialize(&mut **self)
347	}
348
349	fn end(self) -> Result<()> {
350		Ok(())
351	}
352}
353
354impl<'se> ser::SerializeStruct for &mut Serializer<'se> {
355	type Ok = ();
356	type Error = BinaryError;
357
358	fn serialize_field<T>(&mut self, _key: &'static str, value: &T) -> Result<()>
359	where
360		T: ?Sized + Serialize,
361	{
362		value.serialize(&mut **self)
363	}
364
365	fn end(self) -> Result<()> {
366		Ok(())
367	}
368}
369
370impl<'se> ser::SerializeStructVariant for &mut Serializer<'se> {
371	type Ok = ();
372	type Error = BinaryError;
373
374	fn serialize_field<T>(&mut self, _key: &'static str, value: &T) -> Result<()>
375	where
376		T: ?Sized + Serialize,
377	{
378		value.serialize(&mut **self)
379	}
380
381	fn end(self) -> Result<()> {
382		Ok(())
383	}
384}
serde_binary_adv/serde_binary_adv/stream/ser.rs

serde_binary_adv/serde_binary_adv/stream/
ser.rs
