1use serde::ser::Impossible;
2
3use super::Serializer;
4use crate::{Error, Value};
5
6pub enum SerializeSeq {
7 Bytes(Vec<u8>),
8 Array(Vec<Value>),
9}
10
11impl Default for SerializeSeq {
12 fn default() -> Self {
13 Self::new()
14 }
15}
16
17impl SerializeSeq {
18 pub fn new() -> Self {
19 SerializeSeq::Bytes(Vec::new())
20 }
21}
22
23impl TryFrom<Value> for u8 {
24 type Error = Value;
25
26 fn try_from(value: Value) -> Result<Self, Self::Error> {
27 match value {
28 Value::U64(x) => u8::try_from(x).map_err(|_| value),
29 Value::I64(x) => u8::try_from(x).map_err(|_| value),
30 Value::U128(x) => u8::try_from(x).map_err(|_| value),
31 value => Err(value),
32 }
33 }
34}
35
36impl serde::ser::SerializeSeq for SerializeSeq {
37 type Ok = Value;
38 type Error = Error;
39
40 fn serialize_element<T>(&mut self, value: &T) -> Result<(), Error>
41 where
42 T: ?Sized + serde::Serialize,
43 {
44 match self {
45 Self::Array(vec) => {
46 let value = value.serialize(Serializer)?;
47 vec.push(value);
48 }
49 Self::Bytes(vec) => {
50 let value = value.serialize(Serializer)?;
51 match u8::try_from(value) {
52 Ok(v) => vec.push(v),
53 Err(v) => {
54 let Self::Bytes(old) = std::mem::replace(self, Self::Array(Vec::new()))
55 else {
56 unreachable!()
57 };
58 let Self::Array(new) = self else {
59 unreachable!()
60 };
61 new.extend(old.into_iter().map(Value::from).chain(std::iter::once(v)));
62 }
63 }
64 }
65 }
66 Ok(())
67 }
68
69 fn end(self) -> Result<Value, Error> {
70 Ok(match self {
71 Self::Bytes(vec) => {
72 if vec.is_empty() {
73 Value::Array(Vec::new())
74 } else {
75 Value::from(vec)
76 }
77 }
78 Self::Array(vec) => Value::Array(vec),
79 })
80 }
81}
82
83impl serde::ser::SerializeTuple for SerializeSeq {
84 type Ok = Value;
85 type Error = Error;
86
87 fn serialize_element<T>(&mut self, value: &T) -> Result<(), Error>
88 where
89 T: ?Sized + serde::Serialize,
90 {
91 serde::ser::SerializeSeq::serialize_element(self, value)
92 }
93
94 fn end(self) -> Result<Value, Error> {
95 serde::ser::SerializeSeq::end(self)
96 }
97}
98
99impl serde::ser::SerializeTupleStruct for SerializeSeq {
100 type Ok = Value;
101 type Error = Error;
102
103 fn serialize_field<T>(&mut self, value: &T) -> Result<(), Error>
104 where
105 T: ?Sized + serde::Serialize,
106 {
107 serde::ser::SerializeSeq::serialize_element(self, value)
108 }
109
110 fn end(self) -> Result<Value, Error> {
111 serde::ser::SerializeSeq::end(self)
112 }
113}
114
115#[derive(Default)]
116pub struct SerializeSeqNoBytes {
117 array: Vec<Value>,
118}
119
120impl serde::ser::SerializeSeq for SerializeSeqNoBytes {
121 type Ok = Value;
122 type Error = Error;
123
124 fn serialize_element<T>(&mut self, value: &T) -> Result<(), Error>
125 where
126 T: ?Sized + serde::Serialize,
127 {
128 let value = value.serialize(Serializer)?;
129 self.array.push(value);
130 Ok(())
131 }
132
133 fn end(self) -> Result<Value, Error> {
134 Ok(Value::Array(self.array))
135 }
136}
137
138impl serde::Serializer for SerializeSeqNoBytes {
139 type Ok = Value;
140
141 type Error = Error;
142
143 type SerializeSeq = Self;
144
145 type SerializeTuple = Impossible<Value, Error>;
146
147 type SerializeTupleStruct = Impossible<Value, Error>;
148
149 type SerializeTupleVariant = Impossible<Value, Error>;
150
151 type SerializeMap = Impossible<Value, Error>;
152
153 type SerializeStruct = Impossible<Value, Error>;
154
155 type SerializeStructVariant = Impossible<Value, Error>;
156
157 fn serialize_bool(self, _v: bool) -> Result<Self::Ok, Self::Error> {
158 Err(Error::ExpectedArray)
159 }
160
161 fn serialize_i8(self, _v: i8) -> Result<Self::Ok, Self::Error> {
162 Err(Error::ExpectedArray)
163 }
164
165 fn serialize_i16(self, _v: i16) -> Result<Self::Ok, Self::Error> {
166 Err(Error::ExpectedArray)
167 }
168
169 fn serialize_i32(self, _v: i32) -> Result<Self::Ok, Self::Error> {
170 Err(Error::ExpectedArray)
171 }
172
173 fn serialize_i64(self, _v: i64) -> Result<Self::Ok, Self::Error> {
174 Err(Error::ExpectedArray)
175 }
176
177 fn serialize_u8(self, _v: u8) -> Result<Self::Ok, Self::Error> {
178 Err(Error::ExpectedArray)
179 }
180
181 fn serialize_u16(self, _v: u16) -> Result<Self::Ok, Self::Error> {
182 Err(Error::ExpectedArray)
183 }
184
185 fn serialize_u32(self, _v: u32) -> Result<Self::Ok, Self::Error> {
186 Err(Error::ExpectedArray)
187 }
188
189 fn serialize_u64(self, _v: u64) -> Result<Self::Ok, Self::Error> {
190 Err(Error::ExpectedArray)
191 }
192
193 fn serialize_f32(self, _v: f32) -> Result<Self::Ok, Self::Error> {
194 Err(Error::ExpectedArray)
195 }
196
197 fn serialize_f64(self, _v: f64) -> Result<Self::Ok, Self::Error> {
198 Err(Error::ExpectedArray)
199 }
200
201 fn serialize_char(self, _v: char) -> Result<Self::Ok, Self::Error> {
202 Err(Error::ExpectedArray)
203 }
204
205 fn serialize_str(self, _v: &str) -> Result<Self::Ok, Self::Error> {
206 Err(Error::ExpectedArray)
207 }
208
209 fn serialize_bytes(self, _v: &[u8]) -> Result<Self::Ok, Self::Error> {
210 Err(Error::ExpectedArray)
211 }
212
213 fn serialize_none(self) -> Result<Self::Ok, Self::Error> {
214 Err(Error::ExpectedArray)
215 }
216
217 fn serialize_some<T>(self, _value: &T) -> Result<Self::Ok, Self::Error>
218 where
219 T: serde::Serialize + ?Sized,
220 {
221 Err(Error::ExpectedArray)
222 }
223
224 fn serialize_unit(self) -> Result<Self::Ok, Self::Error> {
225 Err(Error::ExpectedArray)
226 }
227
228 fn serialize_unit_struct(self, _name: &'static str) -> Result<Self::Ok, Self::Error> {
229 Err(Error::ExpectedArray)
230 }
231
232 fn serialize_unit_variant(
233 self,
234 _name: &'static str,
235 _variant_index: u32,
236 _variant: &'static str,
237 ) -> Result<Self::Ok, Self::Error> {
238 Err(Error::ExpectedArray)
239 }
240
241 fn serialize_newtype_struct<T>(
242 self,
243 _name: &'static str,
244 _value: &T,
245 ) -> Result<Self::Ok, Self::Error>
246 where
247 T: serde::Serialize + ?Sized,
248 {
249 Err(Error::ExpectedArray)
250 }
251
252 fn serialize_newtype_variant<T>(
253 self,
254 _name: &'static str,
255 _variant_index: u32,
256 _variant: &'static str,
257 _value: &T,
258 ) -> Result<Self::Ok, Self::Error>
259 where
260 T: serde::Serialize + ?Sized,
261 {
262 Err(Error::ExpectedArray)
263 }
264
265 fn serialize_seq(self, len: Option<usize>) -> Result<Self::SerializeSeq, Self::Error> {
266 Ok(Self {
267 array: len.map(Vec::with_capacity).unwrap_or_default(),
268 })
269 }
270
271 fn serialize_tuple(self, _len: usize) -> Result<Self::SerializeTuple, Self::Error> {
272 Err(Error::ExpectedArray)
273 }
274
275 fn serialize_tuple_struct(
276 self,
277 _name: &'static str,
278 _len: usize,
279 ) -> Result<Self::SerializeTupleStruct, Self::Error> {
280 Err(Error::ExpectedArray)
281 }
282
283 fn serialize_tuple_variant(
284 self,
285 _name: &'static str,
286 _variant_index: u32,
287 _variant: &'static str,
288 _len: usize,
289 ) -> Result<Self::SerializeTupleVariant, Self::Error> {
290 Err(Error::ExpectedArray)
291 }
292
293 fn serialize_map(self, _len: Option<usize>) -> Result<Self::SerializeMap, Self::Error> {
294 Err(Error::ExpectedArray)
295 }
296
297 fn serialize_struct(
298 self,
299 _name: &'static str,
300 _len: usize,
301 ) -> Result<Self::SerializeStruct, Self::Error> {
302 Err(Error::ExpectedArray)
303 }
304
305 fn serialize_struct_variant(
306 self,
307 _name: &'static str,
308 _variant_index: u32,
309 _variant: &'static str,
310 _len: usize,
311 ) -> Result<Self::SerializeStructVariant, Self::Error> {
312 Err(Error::ExpectedArray)
313 }
314}
315
316impl serde::ser::SerializeTuple for SerializeSeqNoBytes {
317 type Ok = Value;
318 type Error = Error;
319
320 fn serialize_element<T>(&mut self, value: &T) -> Result<(), Error>
321 where
322 T: ?Sized + serde::Serialize,
323 {
324 serde::ser::SerializeSeq::serialize_element(self, value)
325 }
326
327 fn end(self) -> Result<Value, Error> {
328 serde::ser::SerializeSeq::end(self)
329 }
330}
331
332impl serde::ser::SerializeTupleStruct for SerializeSeqNoBytes {
333 type Ok = Value;
334 type Error = Error;
335
336 fn serialize_field<T>(&mut self, value: &T) -> Result<(), Error>
337 where
338 T: ?Sized + serde::Serialize,
339 {
340 serde::ser::SerializeSeq::serialize_element(self, value)
341 }
342
343 fn end(self) -> Result<Value, Error> {
344 serde::ser::SerializeSeq::end(self)
345 }
346}