1use std::io::Write;
2
3use serde::{ser, Serialize};
4
5use crate::error::{Error, Result};
6
7pub fn to_vec<T: ?Sized + Serialize>(value: &T) -> Result<Vec<u8>> {
8 let mut serializer = Serializer::new(Vec::new())?;
9 value.serialize(&mut serializer)?;
10 serializer.output.push(0);
11 Ok(serializer.output)
12}
13
14pub fn to_writer<W: Write, T: ?Sized + Serialize>(writer: W, value: &T) -> Result<()> {
15 let mut serializer = Serializer::new(writer)?;
16 value.serialize(&mut serializer)?;
17 serializer.output.write_all(&[0])?;
18 Ok(())
19}
20
21enum FieldInfo {
22 None,
23 Named(&'static str),
24 InSeq(Option<i32>),
25}
26
27impl FieldInfo {
28 fn write(&mut self, tag: u8, mut w: impl Write) -> Result<()> {
29 let result = match self {
30 Self::None => Err(Error::FieldInfoUnset),
31 Self::InSeq(size) => {
32 if let Some(x) = size {
33 w.write_all(&[tag])?;
34 w.write_all(&x.to_le_bytes())?;
35 *size = None;
36 }
37 Ok(())
38 }
39 Self::Named(name) => {
40 w.write_all(&[tag])?;
41 let len = u16::try_from(name.len()).map_err(|_| Error::StrLen(name.len()))?;
42 w.write_all(&len.to_le_bytes())?;
43 let mutf8 = mutf8::utf8_to_mutf8(name.as_bytes())?;
44 w.write_all(&mutf8)?;
45 Ok(())
46 }
47 };
48 *self = FieldInfo::None;
49 result
50 }
51}
52
53pub struct Serializer<W: Write> {
54 output: W,
55 field_info: FieldInfo,
56}
57
58impl<W: Write> Serializer<W> {
59 pub fn new(mut output: W) -> Result<Self> {
60 output.write_all(&[0xad, 0x4e, 0x42, 0x54, 0x00, 0x05, 0x80])?;
61 Ok(Self {
62 output,
63 field_info: FieldInfo::Named(""),
64 })
65 }
66}
67
68impl<W: Write> ser::Serializer for &mut Serializer<W> {
69 type Ok = ();
70 type Error = Error;
71
72 type SerializeMap = Self;
73 type SerializeSeq = Self;
74 type SerializeStruct = Self;
75 type SerializeStructVariant = Self;
76 type SerializeTuple = Self;
77 type SerializeTupleStruct = Self;
78 type SerializeTupleVariant = Self;
79
80 fn is_human_readable(&self) -> bool {
81 false
82 }
83
84 fn serialize_bool(self, v: bool) -> Result<()> {
85 self.serialize_u8(v.into())
86 }
87
88 fn serialize_char(self, v: char) -> Result<()> {
89 self.serialize_str(&v.to_string())
90 }
91
92 fn serialize_i8(self, v: i8) -> Result<()> {
93 self.serialize_u8(v as u8)
94 }
95
96 fn serialize_i16(self, v: i16) -> Result<()> {
97 self.serialize_u16(v as u16)
98 }
99
100 fn serialize_i32(self, v: i32) -> Result<()> {
101 self.serialize_u32(v as u32)
102 }
103
104 fn serialize_i64(self, v: i64) -> Result<()> {
105 self.serialize_u64(v as u64)
106 }
107
108 fn serialize_i128(self, v: i128) -> Result<()> {
109 self.serialize_u128(v as u128)
110 }
111
112 fn serialize_u8(self, v: u8) -> Result<()> {
113 self.field_info.write(0x01, &mut self.output)?;
114 self.output.write_all(&[v])?;
115 Ok(())
116 }
117
118 fn serialize_u16(self, v: u16) -> Result<()> {
119 self.field_info.write(0x02, &mut self.output)?;
120 self.output.write_all(&v.to_le_bytes())?;
121 Ok(())
122 }
123
124 fn serialize_u32(self, v: u32) -> Result<()> {
125 self.field_info.write(0x03, &mut self.output)?;
126 self.output.write_all(&v.to_le_bytes())?;
127 Ok(())
128 }
129
130 fn serialize_u64(self, v: u64) -> Result<()> {
131 self.field_info.write(0x04, &mut self.output)?;
132 self.output.write_all(&v.to_le_bytes())?;
133 Ok(())
134 }
135
136 fn serialize_f32(self, v: f32) -> Result<()> {
137 self.field_info.write(0x05, &mut self.output)?;
138 self.output.write_all(&v.to_le_bytes())?;
139 Ok(())
140 }
141
142 fn serialize_f64(self, v: f64) -> Result<()> {
143 self.field_info.write(0x06, &mut self.output)?;
144 self.output.write_all(&v.to_le_bytes())?;
145 Ok(())
146 }
147
148 fn serialize_bytes(self, v: &[u8]) -> Result<()> {
149 self.field_info.write(0x07, &mut self.output)?;
150 let len = i32::try_from(v.len()).map_err(|_| Error::SeqLen(v.len()))?;
151 self.output.write_all(&len.to_le_bytes())?;
152 self.output.write_all(v)?;
153 Ok(())
154 }
155
156 fn serialize_str(self, v: &str) -> Result<()> {
157 self.field_info.write(0x08, &mut self.output)?;
158 let len = u16::try_from(v.len()).map_err(|_| Error::StrLen(v.len()))?;
159 self.output.write_all(&len.to_le_bytes())?;
160 let mutf8 = mutf8::utf8_to_mutf8(v.as_bytes())?;
161 self.output.write_all(&mutf8)?;
162 Ok(())
163 }
164
165 fn serialize_u128(self, v: u128) -> Result<()> {
166 todo!()
167 }
168
169 fn serialize_map(self, _len: Option<usize>) -> Result<Self> {
170 todo!()
171 }
172
173 fn serialize_newtype_struct<T: ?Sized + Serialize>(
174 self,
175 _name: &'static str,
176 value: &T,
177 ) -> Result<()> {
178 value.serialize(self)
179 }
180
181 fn serialize_newtype_variant<T: ?Sized + Serialize>(
182 self,
183 name: &'static str,
184 variant_index: u32,
185 variant: &'static str,
186 value: &T,
187 ) -> Result<()> {
188 todo!()
189 }
190
191 fn serialize_none(self) -> Result<()> {
192 todo!()
193 }
194
195 fn serialize_seq(self, len: Option<usize>) -> Result<Self> {
196 self.field_info.write(0x09, &mut self.output)?;
197 let len = len.unwrap_or_else(|| todo!());
198 let len = len.try_into().map_err(|_| Error::SeqLen(len))?;
199 self.field_info = FieldInfo::InSeq(Some(len));
200 Ok(self)
201 }
202
203 fn serialize_some<T: ?Sized + Serialize>(self, value: &T) -> Result<()> {
204 todo!()
205 }
206
207 fn serialize_struct(self, name: &'static str, len: usize) -> Result<Self> {
208 self.field_info.write(0x0a, &mut self.output)?;
209 Ok(self)
210 }
211
212 fn serialize_struct_variant(
213 self,
214 name: &'static str,
215 variant_index: u32,
216 variant: &'static str,
217 len: usize,
218 ) -> Result<Self> {
219 todo!()
220 }
221
222 fn serialize_tuple(self, len: usize) -> Result<Self> {
223 todo!()
224 }
225
226 fn serialize_tuple_struct(self, name: &'static str, len: usize) -> Result<Self> {
227 todo!()
228 }
229
230 fn serialize_tuple_variant(
231 self,
232 name: &'static str,
233 variant_index: u32,
234 variant: &'static str,
235 len: usize,
236 ) -> Result<Self> {
237 todo!()
238 }
239
240 fn serialize_unit(self) -> Result<()> {
241 todo!()
242 }
243
244 fn serialize_unit_struct(self, name: &'static str) -> Result<()> {
245 todo!()
246 }
247
248 fn serialize_unit_variant(
249 self,
250 name: &'static str,
251 variant_index: u32,
252 variant: &'static str,
253 ) -> Result<()> {
254 todo!()
255 }
256}
257
258impl<W: Write> ser::SerializeMap for &mut Serializer<W> {
259 type Ok = ();
260 type Error = Error;
261
262 fn serialize_key<T: ?Sized + Serialize>(&mut self, key: &T) -> Result<()> {
263 todo!()
264 }
265
266 fn serialize_value<T: ?Sized + Serialize>(&mut self, value: &T) -> Result<()> {
267 todo!()
268 }
269
270 fn end(self) -> Result<()> {
271 todo!()
272 }
273}
274
275impl<W: Write> ser::SerializeSeq for &mut Serializer<W> {
276 type Ok = ();
277 type Error = Error;
278
279 fn serialize_element<T: ?Sized + Serialize>(&mut self, value: &T) -> Result<()> {
280 value.serialize(&mut **self)
281 }
282
283 fn end(self) -> Result<()> {
284 Ok(())
285 }
286}
287
288impl<W: Write> ser::SerializeStruct for &mut Serializer<W> {
289 type Ok = ();
290 type Error = Error;
291
292 fn serialize_field<T: ?Sized + Serialize>(
293 &mut self,
294 key: &'static str,
295 value: &T,
296 ) -> Result<()> {
297 self.field_info = FieldInfo::Named(key);
298 value.serialize(&mut **self)
299 }
300
301 fn end(self) -> Result<()> {
302 self.output.write_all(&[0])?;
303 Ok(())
304 }
305}
306
307impl<W: Write> ser::SerializeStructVariant for &mut Serializer<W> {
308 type Ok = ();
309 type Error = Error;
310
311 fn serialize_field<T: ?Sized + Serialize>(
312 &mut self,
313 key: &'static str,
314 value: &T,
315 ) -> Result<()> {
316 todo!()
317 }
318
319 fn end(self) -> Result<()> {
320 todo!()
321 }
322}
323
324impl<W: Write> ser::SerializeTuple for &mut Serializer<W> {
325 type Ok = ();
326 type Error = Error;
327
328 fn serialize_element<T: ?Sized + Serialize>(&mut self, value: &T) -> Result<()> {
329 todo!()
330 }
331
332 fn end(self) -> Result<()> {
333 todo!()
334 }
335}
336
337impl<W: Write> ser::SerializeTupleStruct for &mut Serializer<W> {
338 type Ok = ();
339 type Error = Error;
340
341 fn serialize_field<T: ?Sized + Serialize>(&mut self, value: &T) -> Result<()> {
342 todo!()
343 }
344
345 fn end(self) -> Result<()> {
346 todo!()
347 }
348}
349
350impl<W: Write> ser::SerializeTupleVariant for &mut Serializer<W> {
351 type Ok = ();
352 type Error = Error;
353
354 fn serialize_field<T: ?Sized + Serialize>(&mut self, value: &T) -> Result<()> {
355 todo!()
356 }
357
358 fn end(self) -> Result<()> {
359 todo!()
360 }
361}