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