uneval/
ser.rs

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

uneval/
ser.rs
