shiny_configuration/value/
serializer.rs

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

shiny_configuration/value/
serializer.rs
