serde_ast/
ser.rs

1//! Implement [Serializer] for [Ast].
2
3use std::fmt::Display;
4
5use crate::{ast, to_ast, Ast};
6
7/// [serde::Serializer::Error] for [Serializer]
8#[derive(Debug, thiserror::Error)]
9#[allow(missing_docs)] // errors are self-documenting
10pub enum Error {
11    #[error("error")]
12    Custom(String),
13}
14impl serde::ser::Error for Error {
15    fn custom<T>(msg: T) -> Self
16    where
17        T: Display,
18    {
19        Self::Custom(msg.to_string())
20    }
21}
22
23/// [Serializer] is a [serde::Serializer] for [Ast].
24#[derive(Debug, Clone)]
25pub struct Serializer {}
26impl Serializer {
27    /// Create a new [Serializer].
28    #[allow(clippy::new_without_default)] // might accept args in the future
29    pub fn new() -> Self {
30        Self {}
31    }
32}
33impl serde::Serializer for Serializer {
34    type Ok = Ast;
35    type Error = Error;
36
37    type SerializeSeq = SerializeSeq;
38    type SerializeTuple = SerializeTuple;
39    type SerializeTupleStruct = SerializeTupleStruct;
40    type SerializeTupleVariant = SerializeTupleVariant;
41    type SerializeMap = SerializeMap;
42    type SerializeStruct = SerializeStruct;
43    type SerializeStructVariant = SerializeStructVariant;
44
45    fn serialize_bool(self, v: bool) -> Result<Self::Ok, Self::Error> {
46        Ok(Ast::Bool(v))
47    }
48    fn serialize_i8(self, v: i8) -> Result<Self::Ok, Self::Error> {
49        Ok(Ast::I8(v))
50    }
51    fn serialize_i16(self, v: i16) -> Result<Self::Ok, Self::Error> {
52        Ok(Ast::I16(v))
53    }
54    fn serialize_i32(self, v: i32) -> Result<Self::Ok, Self::Error> {
55        Ok(Ast::I32(v))
56    }
57    fn serialize_i64(self, v: i64) -> Result<Self::Ok, Self::Error> {
58        Ok(Ast::I64(v))
59    }
60    fn serialize_u8(self, v: u8) -> Result<Self::Ok, Self::Error> {
61        Ok(Ast::U8(v))
62    }
63    fn serialize_u16(self, v: u16) -> Result<Self::Ok, Self::Error> {
64        Ok(Ast::U16(v))
65    }
66    fn serialize_u32(self, v: u32) -> Result<Self::Ok, Self::Error> {
67        Ok(Ast::U32(v))
68    }
69    fn serialize_u64(self, v: u64) -> Result<Self::Ok, Self::Error> {
70        Ok(Ast::U64(v))
71    }
72    fn serialize_f32(self, v: f32) -> Result<Self::Ok, Self::Error> {
73        Ok(Ast::F32(v))
74    }
75    fn serialize_f64(self, v: f64) -> Result<Self::Ok, Self::Error> {
76        Ok(Ast::F64(v))
77    }
78    fn serialize_char(self, v: char) -> Result<Self::Ok, Self::Error> {
79        Ok(Ast::Char(v))
80    }
81    fn serialize_str(self, v: &str) -> Result<Self::Ok, Self::Error> {
82        Ok(Ast::Str(v.to_owned()))
83    }
84    fn serialize_bytes(self, v: &[u8]) -> Result<Self::Ok, Self::Error> {
85        Ok(Ast::Bytes(v.to_owned()))
86    }
87
88    fn serialize_none(self) -> Result<Self::Ok, Self::Error> {
89        Ok(Ast::None)
90    }
91    fn serialize_some<T>(self, value: &T) -> Result<Self::Ok, Self::Error>
92    where
93        T: ?Sized + serde::Serialize,
94    {
95        Ok(Ast::Some(Box::new(to_ast(value)?)))
96    }
97
98    fn serialize_unit(self) -> Result<Self::Ok, Self::Error> {
99        Ok(Ast::Unit)
100    }
101    fn serialize_unit_struct(self, name: &'static str) -> Result<Self::Ok, Self::Error> {
102        Ok(Ast::UnitStruct(name))
103    }
104    fn serialize_unit_variant(
105        self,
106        name: &'static str,
107        variant_index: u32,
108        variant: &'static str,
109    ) -> Result<Self::Ok, Self::Error> {
110        Ok(Ast::UnitVariant {
111            name,
112            variant_index,
113            variant,
114        })
115    }
116
117    fn serialize_newtype_struct<T>(
118        self,
119        name: &'static str,
120        value: &T,
121    ) -> Result<Self::Ok, Self::Error>
122    where
123        T: ?Sized + serde::Serialize,
124    {
125        Ok(Ast::NewtypeStruct {
126            name,
127            value: Box::new(to_ast(value)?),
128        })
129    }
130    fn serialize_newtype_variant<T>(
131        self,
132        name: &'static str,
133        variant_index: u32,
134        variant: &'static str,
135        value: &T,
136    ) -> Result<Self::Ok, Self::Error>
137    where
138        T: ?Sized + serde::Serialize,
139    {
140        Ok(Ast::NewtypeVariant {
141            name,
142            variant_index,
143            variant,
144            value: Box::new(to_ast(value)?),
145        })
146    }
147
148    fn serialize_seq(self, len: Option<usize>) -> Result<Self::SerializeSeq, Self::Error> {
149        Ok(SerializeSeq::new(len))
150    }
151
152    fn serialize_tuple(self, len: usize) -> Result<Self::SerializeTuple, Self::Error> {
153        Ok(SerializeTuple::new(len))
154    }
155    fn serialize_tuple_struct(
156        self,
157        name: &'static str,
158        len: usize,
159    ) -> Result<Self::SerializeTupleStruct, Self::Error> {
160        Ok(SerializeTupleStruct::new(name, len))
161    }
162    fn serialize_tuple_variant(
163        self,
164        name: &'static str,
165        variant_index: u32,
166        variant: &'static str,
167        len: usize,
168    ) -> Result<Self::SerializeTupleVariant, Self::Error> {
169        Ok(SerializeTupleVariant::new(
170            name,
171            variant_index,
172            variant,
173            len,
174        ))
175    }
176
177    fn serialize_map(self, len: Option<usize>) -> Result<Self::SerializeMap, Self::Error> {
178        Ok(SerializeMap::new(len))
179    }
180
181    fn serialize_struct(
182        self,
183        name: &'static str,
184        len: usize,
185    ) -> Result<Self::SerializeStruct, Self::Error> {
186        Ok(SerializeStruct::new(name, len))
187    }
188    fn serialize_struct_variant(
189        self,
190        name: &'static str,
191        variant_index: u32,
192        variant: &'static str,
193        len: usize,
194    ) -> Result<Self::SerializeStructVariant, Self::Error> {
195        Ok(SerializeStructVariant::new(
196            name,
197            variant_index,
198            variant,
199            len,
200        ))
201    }
202}
203
204/// [serde::ser::SerializeTuple] for [Serializer]
205#[derive(Debug, Clone, PartialEq)]
206pub struct SerializeTuple {
207    len: usize,
208    inner_ops: Vec<ast::Tuple>,
209}
210impl SerializeTuple {
211    /// Create new [SerializeTuple].
212    pub fn new(len: usize) -> Self {
213        Self {
214            len,
215            inner_ops: Vec::new(),
216        }
217    }
218}
219impl serde::ser::SerializeTuple for SerializeTuple {
220    type Ok = Ast;
221    type Error = Error;
222
223    fn serialize_element<T>(&mut self, value: &T) -> Result<(), Self::Error>
224    where
225        T: ?Sized + serde::Serialize,
226    {
227        self.inner_ops.push(ast::Tuple::Element {
228            value: Box::new(to_ast(value)?),
229        });
230        Ok(())
231    }
232
233    fn end(self) -> Result<Self::Ok, Self::Error> {
234        let Self { len, inner_ops } = self;
235
236        Ok(Ast::Tuple {
237            len,
238            ops: inner_ops,
239        })
240    }
241}
242
243/// [serde::ser::SerializeTupleStruct] for [Serializer]
244#[derive(Debug, Clone, PartialEq)]
245pub struct SerializeTupleStruct {
246    name: &'static str,
247    len: usize,
248    inner_ops: Vec<ast::TupleStruct>,
249}
250impl SerializeTupleStruct {
251    /// Create new [SerializeTupleStruct].
252    pub fn new(name: &'static str, len: usize) -> Self {
253        Self {
254            name,
255            len,
256            inner_ops: Vec::new(),
257        }
258    }
259}
260impl serde::ser::SerializeTupleStruct for SerializeTupleStruct {
261    type Ok = Ast;
262    type Error = Error;
263
264    fn end(self) -> Result<Self::Ok, Self::Error> {
265        let Self {
266            name,
267            len,
268            inner_ops,
269        } = self;
270
271        Ok(Ast::TupleStruct {
272            name,
273            len,
274            ops: inner_ops,
275        })
276    }
277
278    fn serialize_field<T>(&mut self, value: &T) -> Result<(), Self::Error>
279    where
280        T: ?Sized + serde::Serialize,
281    {
282        self.inner_ops.push(ast::TupleStruct::Field {
283            value: Box::new(to_ast(value)?),
284        });
285        Ok(())
286    }
287}
288
289/// [serde::ser::SerializeTupleVariant] for [Serializer]
290#[derive(Debug, Clone, PartialEq)]
291pub struct SerializeTupleVariant {
292    name: &'static str,
293    variant_index: u32,
294    variant: &'static str,
295    len: usize,
296    inner_ops: Vec<ast::TupleVariant>,
297}
298impl SerializeTupleVariant {
299    /// Create new [SerializeTupleVariant].
300    pub fn new(name: &'static str, variant_index: u32, variant: &'static str, len: usize) -> Self {
301        Self {
302            name,
303            variant_index,
304            variant,
305            len,
306            inner_ops: Vec::new(),
307        }
308    }
309}
310impl serde::ser::SerializeTupleVariant for SerializeTupleVariant {
311    type Ok = Ast;
312    type Error = Error;
313
314    fn end(self) -> Result<Self::Ok, Self::Error> {
315        let Self {
316            name,
317            variant_index,
318            variant,
319            len,
320            inner_ops,
321        } = self;
322
323        Ok(Ast::TupleVariant {
324            name,
325            variant_index,
326            variant,
327            len,
328            ops: inner_ops,
329        })
330    }
331
332    fn serialize_field<T>(&mut self, value: &T) -> Result<(), Self::Error>
333    where
334        T: ?Sized + serde::Serialize,
335    {
336        self.inner_ops.push(ast::TupleVariant::Field {
337            value: Box::new(to_ast(value)?),
338        });
339        Ok(())
340    }
341}
342
343/// [serde::ser::SerializeSeq] for [Serializer]
344#[derive(Debug, Clone, PartialEq)]
345pub struct SerializeSeq {
346    len: Option<usize>,
347    inner_ops: Vec<ast::Seq>,
348}
349impl SerializeSeq {
350    /// Create new [SerializeSeq].
351    pub fn new(len: Option<usize>) -> Self {
352        Self {
353            len,
354            inner_ops: Vec::new(),
355        }
356    }
357}
358impl serde::ser::SerializeSeq for SerializeSeq {
359    type Ok = Ast;
360    type Error = Error;
361
362    fn serialize_element<T>(&mut self, value: &T) -> Result<(), Self::Error>
363    where
364        T: ?Sized + serde::Serialize,
365    {
366        self.inner_ops.push(ast::Seq::Element {
367            value: Box::new(to_ast(value)?),
368        });
369        Ok(())
370    }
371
372    fn end(self) -> Result<Self::Ok, Self::Error> {
373        let Self { len, inner_ops } = self;
374
375        Ok(Ast::Seq {
376            len,
377            ops: inner_ops,
378        })
379    }
380}
381
382/// [serde::ser::SerializeMap] for [Serializer]
383#[derive(Debug, Clone, PartialEq)]
384pub struct SerializeMap {
385    len: Option<usize>,
386    inner_ops: Vec<ast::Map>,
387}
388impl SerializeMap {
389    /// Create new [SerializeMap].
390    pub fn new(len: Option<usize>) -> Self {
391        Self {
392            len,
393            inner_ops: Vec::new(),
394        }
395    }
396}
397impl serde::ser::SerializeMap for SerializeMap {
398    type Ok = Ast;
399    type Error = Error;
400
401    fn serialize_key<T>(&mut self, key: &T) -> Result<(), Self::Error>
402    where
403        T: ?Sized + serde::Serialize,
404    {
405        self.inner_ops.push(ast::Map::Key {
406            key: Box::new(to_ast(key)?),
407        });
408        Ok(())
409    }
410    fn serialize_value<T>(&mut self, value: &T) -> Result<(), Self::Error>
411    where
412        T: ?Sized + serde::Serialize,
413    {
414        self.inner_ops.push(ast::Map::Value {
415            value: Box::new(to_ast(value)?),
416        });
417        Ok(())
418    }
419
420    fn end(self) -> Result<Self::Ok, Self::Error> {
421        let Self { len, inner_ops } = self;
422
423        Ok(Ast::Map {
424            len,
425            ops: inner_ops,
426        })
427    }
428}
429
430/// [serde::ser::SerializeStruct] for [Serializer]
431#[derive(Debug, Clone, PartialEq)]
432pub struct SerializeStruct {
433    name: &'static str,
434    len: usize,
435    inner_ops: Vec<ast::Struct>,
436}
437impl SerializeStruct {
438    /// Create new [SerializeStruct].
439    pub fn new(name: &'static str, len: usize) -> Self {
440        Self {
441            name,
442            len,
443            inner_ops: Vec::new(),
444        }
445    }
446}
447impl serde::ser::SerializeStruct for SerializeStruct {
448    type Ok = Ast;
449    type Error = Error;
450
451    fn serialize_field<T>(&mut self, key: &'static str, value: &T) -> Result<(), Self::Error>
452    where
453        T: ?Sized + serde::Serialize,
454    {
455        self.inner_ops.push(ast::Struct::Field {
456            key,
457            value: Box::new(to_ast(value)?),
458        });
459        Ok(())
460    }
461
462    fn end(self) -> Result<Self::Ok, Self::Error> {
463        let Self {
464            name,
465            len,
466            inner_ops,
467        } = self;
468
469        Ok(Ast::Struct {
470            name,
471            len,
472            ops: inner_ops,
473        })
474    }
475
476    fn skip_field(&mut self, key: &'static str) -> Result<(), Self::Error> {
477        self.inner_ops.push(ast::Struct::Skip { key });
478        Ok(())
479    }
480}
481
482/// [serde::ser::SerializeStructVariant] for [Serializer]
483#[derive(Debug, Clone, PartialEq)]
484pub struct SerializeStructVariant {
485    name: &'static str,
486    variant_index: u32,
487    variant: &'static str,
488    len: usize,
489    inner_ops: Vec<ast::StructVariant>,
490}
491impl SerializeStructVariant {
492    /// Create new [SerializeStructVariant].
493    pub fn new(name: &'static str, variant_index: u32, variant: &'static str, len: usize) -> Self {
494        Self {
495            name,
496            variant_index,
497            variant,
498            len,
499            inner_ops: Vec::new(),
500        }
501    }
502}
503impl serde::ser::SerializeStructVariant for SerializeStructVariant {
504    type Ok = Ast;
505    type Error = Error;
506
507    fn serialize_field<T>(&mut self, key: &'static str, value: &T) -> Result<(), Self::Error>
508    where
509        T: ?Sized + serde::Serialize,
510    {
511        self.inner_ops.push(ast::StructVariant::Field {
512            key,
513            value: Box::new(to_ast(value)?),
514        });
515        Ok(())
516    }
517
518    fn end(self) -> Result<Self::Ok, Self::Error> {
519        let Self {
520            name,
521            variant_index,
522            variant,
523            len,
524            inner_ops,
525        } = self;
526
527        Ok(Ast::StructVariant {
528            name,
529            variant_index,
530            variant,
531            len,
532            ops: inner_ops,
533        })
534    }
535
536    fn skip_field(&mut self, key: &'static str) -> Result<(), Self::Error> {
537        self.inner_ops.push(ast::StructVariant::Skip { key });
538        Ok(())
539    }
540}
serde_ast/ser.rs

serde_ast/
ser.rs
