1use crate::reader::tape::TapeElement;
6use lexical_core::FormattedSize;
7use serde_core::ser::{
8 Impossible, SerializeMap, SerializeSeq, SerializeStruct, SerializeTuple, SerializeTupleStruct,
9};
10use serde_core::{Serialize, Serializer};
11
12#[derive(Debug)]
13pub struct SerializerError(String);
14
15impl std::error::Error for SerializerError {}
16
17impl std::fmt::Display for SerializerError {
18 fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
19 write!(f, "{}", self.0)
20 }
21}
22
23impl serde_core::ser::Error for SerializerError {
24 fn custom<T>(msg: T) -> Self
25 where
26 T: std::fmt::Display,
27 {
28 Self(msg.to_string())
29 }
30}
31
32pub struct TapeSerializer<'a> {
36 elements: &'a mut Vec<TapeElement>,
37
38 bytes: &'a mut Vec<u8>,
40
41 offsets: &'a mut Vec<usize>,
43}
44
45impl<'a> TapeSerializer<'a> {
46 pub fn new(
47 elements: &'a mut Vec<TapeElement>,
48 bytes: &'a mut Vec<u8>,
49 offsets: &'a mut Vec<usize>,
50 ) -> Self {
51 Self {
52 elements,
53 bytes,
54 offsets,
55 }
56 }
57
58 fn serialize_number(&mut self, v: &[u8]) {
59 self.bytes.extend_from_slice(v);
60 let idx = self.offsets.len() - 1;
61 self.elements.push(TapeElement::Number(idx as _));
62 self.offsets.push(self.bytes.len());
63 }
64}
65
66impl<'a, 'b> Serializer for &'a mut TapeSerializer<'b> {
67 type Ok = ();
68
69 type Error = SerializerError;
70
71 type SerializeSeq = ListSerializer<'a, 'b>;
72 type SerializeTuple = ListSerializer<'a, 'b>;
73 type SerializeTupleStruct = ListSerializer<'a, 'b>;
74 type SerializeTupleVariant = Impossible<(), SerializerError>;
75 type SerializeMap = ObjectSerializer<'a, 'b>;
76 type SerializeStruct = ObjectSerializer<'a, 'b>;
77 type SerializeStructVariant = Impossible<(), SerializerError>;
78
79 fn serialize_bool(self, v: bool) -> Result<(), SerializerError> {
80 self.elements.push(match v {
81 true => TapeElement::True,
82 false => TapeElement::False,
83 });
84 Ok(())
85 }
86
87 fn serialize_i8(self, v: i8) -> Result<(), SerializerError> {
88 self.serialize_i32(v as _)
89 }
90
91 fn serialize_i16(self, v: i16) -> Result<(), SerializerError> {
92 self.serialize_i32(v as _)
93 }
94
95 fn serialize_i32(self, v: i32) -> Result<(), SerializerError> {
96 self.elements.push(TapeElement::I32(v));
97 Ok(())
98 }
99
100 fn serialize_i64(self, v: i64) -> Result<(), SerializerError> {
101 let low = v as i32;
102 let high = (v >> 32) as i32;
103 self.elements.push(TapeElement::I64(high));
104 self.elements.push(TapeElement::I32(low));
105 Ok(())
106 }
107
108 fn serialize_u8(self, v: u8) -> Result<(), SerializerError> {
109 self.serialize_i32(v as _)
110 }
111
112 fn serialize_u16(self, v: u16) -> Result<(), SerializerError> {
113 self.serialize_i32(v as _)
114 }
115
116 fn serialize_u32(self, v: u32) -> Result<(), SerializerError> {
117 match i32::try_from(v) {
118 Ok(v) => self.serialize_i32(v),
119 Err(_) => self.serialize_i64(v as _),
120 }
121 }
122
123 fn serialize_u64(self, v: u64) -> Result<(), SerializerError> {
124 match i64::try_from(v) {
125 Ok(v) => self.serialize_i64(v),
126 Err(_) => {
127 let mut buffer = [0_u8; u64::FORMATTED_SIZE];
128 let s = lexical_core::write(v, &mut buffer);
129 self.serialize_number(s);
130 Ok(())
131 }
132 }
133 }
134
135 fn serialize_f32(self, v: f32) -> Result<(), SerializerError> {
136 self.elements.push(TapeElement::F32(v.to_bits()));
137 Ok(())
138 }
139
140 fn serialize_f64(self, v: f64) -> Result<(), SerializerError> {
141 let bits = v.to_bits();
142 self.elements.push(TapeElement::F64((bits >> 32) as u32));
143 self.elements.push(TapeElement::F32(bits as u32));
144 Ok(())
145 }
146
147 fn serialize_char(self, v: char) -> Result<(), SerializerError> {
148 self.serialize_str(&v.to_string())
149 }
150
151 fn serialize_str(self, v: &str) -> Result<(), SerializerError> {
152 self.serialize_bytes(v.as_bytes())
153 }
154
155 fn serialize_bytes(self, v: &[u8]) -> Result<(), SerializerError> {
156 self.bytes.extend_from_slice(v);
157 let idx = self.offsets.len() - 1;
158 self.elements.push(TapeElement::String(idx as _));
159 self.offsets.push(self.bytes.len());
160 Ok(())
161 }
162
163 fn serialize_none(self) -> Result<(), SerializerError> {
164 self.serialize_unit()
165 }
166
167 fn serialize_some<T>(self, value: &T) -> Result<(), SerializerError>
168 where
169 T: ?Sized + Serialize,
170 {
171 value.serialize(self)
172 }
173
174 fn serialize_unit(self) -> Result<(), SerializerError> {
175 self.elements.push(TapeElement::Null);
176 Ok(())
177 }
178
179 fn serialize_unit_struct(self, _name: &'static str) -> Result<(), SerializerError> {
180 self.serialize_unit()
181 }
182
183 fn serialize_unit_variant(
184 self,
185 _name: &'static str,
186 _variant_index: u32,
187 variant: &'static str,
188 ) -> Result<(), SerializerError> {
189 self.serialize_str(variant)
190 }
191
192 fn serialize_newtype_struct<T>(
193 self,
194 _name: &'static str,
195 value: &T,
196 ) -> Result<(), SerializerError>
197 where
198 T: ?Sized + Serialize,
199 {
200 value.serialize(self)
201 }
202
203 fn serialize_newtype_variant<T>(
204 self,
205 _name: &'static str,
206 _variant_index: u32,
207 variant: &'static str,
208 value: &T,
209 ) -> Result<(), SerializerError>
210 where
211 T: ?Sized + Serialize,
212 {
213 let mut serializer = self.serialize_map(Some(1))?;
214 serializer.serialize_key(variant)?;
215 serializer.serialize_value(value)?;
216 serializer.finish();
217 Ok(())
218 }
219
220 fn serialize_seq(self, _len: Option<usize>) -> Result<Self::SerializeSeq, SerializerError> {
221 Ok(ListSerializer::new(self))
222 }
223
224 fn serialize_tuple(self, len: usize) -> Result<Self::SerializeTuple, SerializerError> {
225 self.serialize_seq(Some(len))
226 }
227
228 fn serialize_tuple_struct(
229 self,
230 _name: &'static str,
231 len: usize,
232 ) -> Result<Self::SerializeTupleStruct, SerializerError> {
233 self.serialize_seq(Some(len))
234 }
235
236 fn serialize_tuple_variant(
237 self,
238 name: &'static str,
239 _variant_index: u32,
240 variant: &'static str,
241 _len: usize,
242 ) -> Result<Self::SerializeTupleVariant, SerializerError> {
243 Err(SerializerError(format!(
244 "serializing tuple variants is not currently supported: {name}::{variant}"
245 )))
246 }
247
248 fn serialize_map(self, _len: Option<usize>) -> Result<Self::SerializeMap, SerializerError> {
250 Ok(ObjectSerializer::new(self))
251 }
252
253 fn serialize_struct(
254 self,
255 _name: &'static str,
256 len: usize,
257 ) -> Result<Self::SerializeStruct, SerializerError> {
258 self.serialize_map(Some(len))
259 }
260
261 fn serialize_struct_variant(
262 self,
263 name: &'static str,
264 _variant_index: u32,
265 variant: &'static str,
266 _len: usize,
267 ) -> Result<Self::SerializeStructVariant, SerializerError> {
268 Err(SerializerError(format!(
269 "serializing struct variants is not currently supported: {name}::{variant}"
270 )))
271 }
272}
273
274pub struct ObjectSerializer<'a, 'b> {
275 serializer: &'a mut TapeSerializer<'b>,
276 start: usize,
277}
278
279impl<'a, 'b> ObjectSerializer<'a, 'b> {
280 fn new(serializer: &'a mut TapeSerializer<'b>) -> Self {
281 let start = serializer.elements.len();
282 serializer.elements.push(TapeElement::StartObject(0));
283 Self { serializer, start }
284 }
285
286 fn finish(self) {
287 let end = self.serializer.elements.len() as _;
288 self.serializer.elements[self.start] = TapeElement::StartObject(end);
289
290 let end = TapeElement::EndObject(self.start as _);
291 self.serializer.elements.push(end);
292 }
293}
294
295impl SerializeMap for ObjectSerializer<'_, '_> {
296 type Ok = ();
297 type Error = SerializerError;
298
299 fn serialize_key<T>(&mut self, key: &T) -> Result<(), Self::Error>
300 where
301 T: Serialize + ?Sized,
302 {
303 key.serialize(&mut *self.serializer)
304 }
305
306 fn serialize_value<T>(&mut self, value: &T) -> Result<(), Self::Error>
307 where
308 T: Serialize + ?Sized,
309 {
310 value.serialize(&mut *self.serializer)
311 }
312
313 fn end(self) -> Result<(), Self::Error> {
314 self.finish();
315 Ok(())
316 }
317}
318
319impl SerializeStruct for ObjectSerializer<'_, '_> {
320 type Ok = ();
321 type Error = SerializerError;
322
323 fn serialize_field<T>(&mut self, key: &'static str, value: &T) -> Result<(), Self::Error>
324 where
325 T: Serialize + ?Sized,
326 {
327 key.serialize(&mut *self.serializer)?;
328 value.serialize(&mut *self.serializer)
329 }
330
331 fn end(self) -> Result<(), Self::Error> {
332 self.finish();
333 Ok(())
334 }
335}
336
337pub struct ListSerializer<'a, 'b> {
338 serializer: &'a mut TapeSerializer<'b>,
339 start: usize,
340}
341
342impl<'a, 'b> ListSerializer<'a, 'b> {
343 fn new(serializer: &'a mut TapeSerializer<'b>) -> Self {
344 let start = serializer.elements.len();
345 serializer.elements.push(TapeElement::StartList(0));
346 Self { serializer, start }
347 }
348
349 fn finish(self) {
350 let end = self.serializer.elements.len() as _;
351 self.serializer.elements[self.start] = TapeElement::StartList(end);
352
353 let end = TapeElement::EndList(self.start as _);
354 self.serializer.elements.push(end);
355 }
356}
357
358impl SerializeSeq for ListSerializer<'_, '_> {
359 type Ok = ();
360 type Error = SerializerError;
361
362 fn serialize_element<T>(&mut self, value: &T) -> Result<(), Self::Error>
363 where
364 T: Serialize + ?Sized,
365 {
366 value.serialize(&mut *self.serializer)
367 }
368
369 fn end(self) -> Result<(), Self::Error> {
370 self.finish();
371 Ok(())
372 }
373}
374
375impl SerializeTuple for ListSerializer<'_, '_> {
376 type Ok = ();
377 type Error = SerializerError;
378
379 fn serialize_element<T>(&mut self, value: &T) -> Result<(), Self::Error>
380 where
381 T: Serialize + ?Sized,
382 {
383 value.serialize(&mut *self.serializer)
384 }
385
386 fn end(self) -> Result<(), Self::Error> {
387 self.finish();
388 Ok(())
389 }
390}
391
392impl SerializeTupleStruct for ListSerializer<'_, '_> {
393 type Ok = ();
394 type Error = SerializerError;
395
396 fn serialize_field<T>(&mut self, value: &T) -> Result<(), Self::Error>
397 where
398 T: Serialize + ?Sized,
399 {
400 value.serialize(&mut *self.serializer)
401 }
402
403 fn end(self) -> Result<(), Self::Error> {
404 self.finish();
405 Ok(())
406 }
407}