1use super::{MapSerializer, Serializer};
2use crate::{Value, error::Error, headers::ArrayKind};
3use serde::{
4 Serialize,
5 ser::{SerializeSeq, SerializeTuple, SerializeTupleStruct, SerializeTupleVariant},
6};
7use std::io::Write;
8
9pub struct SeqSerializer<'a, W: Write> {
10 serializer: &'a mut Serializer<W>,
11 kind: Option<ArrayKind>,
12 elements: Vec<Value>,
13}
14
15impl<'a, W: Write> SeqSerializer<'a, W> {
16 pub fn new(serializer: &'a mut Serializer<W>) -> Self {
17 serializer.write = false;
18 Self {
19 serializer,
20 kind: None,
21 elements: Vec::new(),
22 }
23 }
24
25 fn update_type(&mut self, new: ArrayKind) {
26 match self.kind {
27 None => self.kind = Some(new),
28 Some(ArrayKind::Generic) => {}
29 Some(kind) => {
30 if kind != new {
31 self.kind = Some(ArrayKind::Generic);
32 }
33 }
34 }
35 }
36
37 fn ensure_generic(&mut self) {
38 if self.kind != Some(ArrayKind::Generic) {
39 self.kind = Some(ArrayKind::Generic);
40 }
41 }
42}
43
44impl<'a, W: Write> SerializeSeq for SeqSerializer<'a, W> {
45 type Ok = Value;
46 type Error = Error;
47
48 fn serialize_element<T>(&mut self, value: &T) -> Result<(), Self::Error>
49 where
50 T: ?Sized + Serialize,
51 {
52 let v = value.serialize(&mut *self)?;
53 self.elements.push(v);
54 Ok(())
55 }
56
57 fn end(self) -> Result<Self::Ok, Self::Error> {
58 let out = match self.kind {
59 Some(ArrayKind::BF16) | Some(ArrayKind::F16) | Some(ArrayKind::F128) => {
60 unreachable!()
61 }
62 None | Some(ArrayKind::Generic) => Value::GenericArray(self.elements),
63 Some(ArrayKind::I8) => Value::I8Array(
64 self.elements
65 .into_iter()
66 .map(|v| match v {
67 Value::I8(v) => v,
68 _ => unreachable!(),
69 })
70 .collect(),
71 ),
72 Some(ArrayKind::I16) => Value::I16Array(
73 self.elements
74 .into_iter()
75 .map(|v| match v {
76 Value::I16(v) => v,
77 _ => unreachable!(),
78 })
79 .collect(),
80 ),
81 Some(ArrayKind::I32) => Value::I32Array(
82 self.elements
83 .into_iter()
84 .map(|v| match v {
85 Value::I32(v) => v,
86 _ => unreachable!(),
87 })
88 .collect(),
89 ),
90 Some(ArrayKind::I64) => Value::I64Array(
91 self.elements
92 .into_iter()
93 .map(|v| match v {
94 Value::I64(v) => v,
95 _ => unreachable!(),
96 })
97 .collect(),
98 ),
99 Some(ArrayKind::I128) => Value::I128Array(
100 self.elements
101 .into_iter()
102 .map(|v| match v {
103 Value::I128(v) => v,
104 _ => unreachable!(),
105 })
106 .collect(),
107 ),
108
109 Some(ArrayKind::U8) => Value::U8Array(
110 self.elements
111 .into_iter()
112 .map(|v| match v {
113 Value::U8(v) => v,
114 _ => unreachable!(),
115 })
116 .collect(),
117 ),
118 Some(ArrayKind::U16) => Value::U16Array(
119 self.elements
120 .into_iter()
121 .map(|v| match v {
122 Value::U16(v) => v,
123 _ => unreachable!(),
124 })
125 .collect(),
126 ),
127 Some(ArrayKind::U32) => Value::U32Array(
128 self.elements
129 .into_iter()
130 .map(|v| match v {
131 Value::U32(v) => v,
132 _ => unreachable!(),
133 })
134 .collect(),
135 ),
136 Some(ArrayKind::U64) => Value::U64Array(
137 self.elements
138 .into_iter()
139 .map(|v| match v {
140 Value::U64(v) => v,
141 _ => unreachable!(),
142 })
143 .collect(),
144 ),
145 Some(ArrayKind::U128) => Value::U128Array(
146 self.elements
147 .into_iter()
148 .map(|v| match v {
149 Value::U128(v) => v,
150 _ => unreachable!(),
151 })
152 .collect(),
153 ),
154
155 Some(ArrayKind::F32) => Value::F32Array(
156 self.elements
157 .into_iter()
158 .map(|v| match v {
159 Value::F32(v) => v,
160 _ => unreachable!(),
161 })
162 .collect(),
163 ),
164 Some(ArrayKind::F64) => Value::F64Array(
165 self.elements
166 .into_iter()
167 .map(|v| match v {
168 Value::F64(v) => v,
169 _ => unreachable!(),
170 })
171 .collect(),
172 ),
173
174 Some(ArrayKind::String) => Value::StringArray(
175 self.elements
176 .into_iter()
177 .map(|v| match v {
178 Value::String(v) => v,
179 _ => unreachable!(),
180 })
181 .collect(),
182 ),
183
184 Some(ArrayKind::Boolean) => {
185 let len = self.elements.len();
186 let values = self.elements.chunks(8).flat_map(|v| {
187 v.iter()
188 .map(|v| match v {
189 Value::True => true,
190 Value::False => false,
191 _ => unreachable!(),
192 })
193 .rev()
194 });
195 let mut bytes = Vec::with_capacity(len);
196 let mut byte = 0;
197 for (i, v) in values.enumerate() {
198 byte |= v as u8;
199 if i % 8 == 7 || i == len - 1 {
200 bytes.push(byte);
201 byte = 0;
202 }
203 byte <<= 1;
204 }
205 Value::BoolArray(len, bytes)
206 }
207 Some(ArrayKind::Complex) => unreachable!(),
208 };
209
210 self.serializer.write = true;
211 self.serializer.serialize_value(&out)?;
212 Ok(out)
213 }
214}
215
216impl<'a, W: Write> SerializeTuple for SeqSerializer<'a, W> {
217 type Ok = Value;
218 type Error = Error;
219
220 fn serialize_element<T>(&mut self, value: &T) -> Result<(), Self::Error>
221 where
222 T: ?Sized + Serialize,
223 {
224 SerializeSeq::serialize_element(self, value)
225 }
226
227 fn end(self) -> Result<Self::Ok, Self::Error> {
228 SerializeSeq::end(self)
229 }
230}
231
232impl<'a, W: Write> SerializeTupleStruct for SeqSerializer<'a, W> {
233 type Ok = Value;
234 type Error = Error;
235
236 fn serialize_field<T>(&mut self, value: &T) -> Result<(), Self::Error>
237 where
238 T: ?Sized + Serialize,
239 {
240 SerializeSeq::serialize_element(self, value)
241 }
242
243 fn end(self) -> Result<Self::Ok, Self::Error> {
244 SerializeSeq::end(self)
245 }
246}
247
248impl<'a, W: Write> SerializeTupleVariant for SeqSerializer<'a, W> {
249 type Ok = Value;
250 type Error = Error;
251
252 fn serialize_field<T>(&mut self, value: &T) -> Result<(), Self::Error>
253 where
254 T: ?Sized + Serialize,
255 {
256 SerializeSeq::serialize_element(self, value)
257 }
258
259 fn end(self) -> Result<Self::Ok, Self::Error> {
260 SerializeSeq::end(self)
261 }
262}
263
264macro_rules! serialize_seq_type {
265 ($fn:ident, $ty:ty, $kind:ident) => {
266 fn $fn(self, v: $ty) -> Result<Self::Ok, Self::Error> {
267 self.update_type(ArrayKind::$kind);
268 self.serializer.$fn(v)
269 }
270 };
271}
272
273impl<'a, 'b, W: Write> serde::Serializer for &'b mut SeqSerializer<'a, W> {
274 type Ok = Value;
275 type Error = Error;
276
277 type SerializeSeq = SeqSerializer<'b, W>;
278 type SerializeTuple = SeqSerializer<'b, W>;
279 type SerializeTupleStruct = SeqSerializer<'b, W>;
280 type SerializeTupleVariant = SeqSerializer<'b, W>;
281 type SerializeMap = MapSerializer<'b, W>;
282 type SerializeStruct = MapSerializer<'b, W>;
283 type SerializeStructVariant = MapSerializer<'b, W>;
284
285 serialize_seq_type!(serialize_bool, bool, Boolean);
286 serialize_seq_type!(serialize_i8, i8, I8);
287 serialize_seq_type!(serialize_i16, i16, I16);
288 serialize_seq_type!(serialize_i32, i32, I32);
289 serialize_seq_type!(serialize_i64, i64, I64);
290 serialize_seq_type!(serialize_i128, i128, I128);
291 serialize_seq_type!(serialize_u8, u8, U8);
292 serialize_seq_type!(serialize_u16, u16, U16);
293 serialize_seq_type!(serialize_u32, u32, U32);
294 serialize_seq_type!(serialize_u64, u64, U64);
295 serialize_seq_type!(serialize_u128, u128, U128);
296 serialize_seq_type!(serialize_f32, f32, F32);
297 serialize_seq_type!(serialize_f64, f64, F64);
298 serialize_seq_type!(serialize_str, &str, String);
299
300 fn serialize_char(self, v: char) -> Result<Self::Ok, Self::Error> {
301 self.serialize_str(&v.to_string())
302 }
303
304 fn serialize_bytes(self, v: &[u8]) -> Result<Self::Ok, Self::Error> {
305 self.ensure_generic();
306 self.serializer.serialize_bytes(v)
307 }
308
309 fn serialize_none(self) -> Result<Self::Ok, Self::Error> {
310 self.serialize_unit()
311 }
312
313 fn serialize_some<T>(self, value: &T) -> Result<Self::Ok, Self::Error>
314 where
315 T: ?Sized + serde::Serialize,
316 {
317 value.serialize(self)
318 }
319
320 fn serialize_unit(self) -> Result<Self::Ok, Self::Error> {
321 self.ensure_generic();
322 self.serializer.serialize_unit()
323 }
324
325 fn serialize_unit_struct(self, _name: &'static str) -> Result<Self::Ok, Self::Error> {
326 self.serialize_unit()
327 }
328
329 fn serialize_unit_variant(
330 self,
331 name: &'static str,
332 variant_index: u32,
333 variant: &'static str,
334 ) -> Result<Self::Ok, Self::Error> {
335 self.ensure_generic();
336 self.serializer
337 .serialize_unit_variant(name, variant_index, variant)
338 }
339
340 fn serialize_newtype_struct<T>(
341 self,
342 _name: &'static str,
343 value: &T,
344 ) -> Result<Self::Ok, Self::Error>
345 where
346 T: ?Sized + serde::Serialize,
347 {
348 value.serialize(self)
349 }
350
351 fn serialize_newtype_variant<T>(
352 self,
353 name: &'static str,
354 variant_index: u32,
355 variant: &'static str,
356 value: &T,
357 ) -> Result<Self::Ok, Self::Error>
358 where
359 T: ?Sized + serde::Serialize,
360 {
361 self.ensure_generic();
362 self.serializer
363 .serialize_newtype_variant(name, variant_index, variant, value)
364 }
365
366 fn serialize_seq(self, len: Option<usize>) -> Result<Self::SerializeSeq, Self::Error> {
367 self.ensure_generic();
368 self.serializer.serialize_seq(len)
369 }
370
371 fn serialize_tuple(self, len: usize) -> Result<Self::SerializeTuple, Self::Error> {
372 self.ensure_generic();
373 self.serializer.serialize_tuple(len)
374 }
375
376 fn serialize_tuple_struct(
377 self,
378 name: &'static str,
379 len: usize,
380 ) -> Result<Self::SerializeTupleStruct, Self::Error> {
381 self.ensure_generic();
382 self.serializer.serialize_tuple_struct(name, len)
383 }
384
385 fn serialize_tuple_variant(
386 self,
387 name: &'static str,
388 variant_index: u32,
389 variant: &'static str,
390 len: usize,
391 ) -> Result<Self::SerializeTupleVariant, Self::Error> {
392 self.ensure_generic();
393 self.serializer
394 .serialize_tuple_variant(name, variant_index, variant, len)
395 }
396
397 fn serialize_map(self, len: Option<usize>) -> Result<Self::SerializeMap, Self::Error> {
398 self.ensure_generic();
399 self.serializer.serialize_map(len)
400 }
401
402 fn serialize_struct(
403 self,
404 name: &'static str,
405 len: usize,
406 ) -> Result<Self::SerializeStruct, Self::Error> {
407 self.ensure_generic();
408 self.serializer.serialize_struct(name, len)
409 }
410
411 fn serialize_struct_variant(
412 self,
413 name: &'static str,
414 variant_index: u32,
415 variant: &'static str,
416 len: usize,
417 ) -> Result<Self::SerializeStructVariant, Self::Error> {
418 self.ensure_generic();
419 self.serializer
420 .serialize_struct_variant(name, variant_index, variant, len)
421 }
422}