serde_ast/
ast.rs

1//! Define the [Ast] representation of [serde] serialization.
2
3use std::fmt::Display;
4
5use serde::{
6    ser::{
7        SerializeMap, SerializeSeq, SerializeStruct, SerializeStructVariant, SerializeTuple,
8        SerializeTupleStruct, SerializeTupleVariant,
9    },
10    Serialize,
11};
12
13/// Represent calls made to [serde::Serializer] during serialization.
14#[derive(Debug, Clone, PartialEq)]
15pub enum Ast {
16    /// [serde::Serializer::serialize_bool]
17    Bool(bool),
18
19    /// [serde::Serializer::serialize_i8]
20    I8(i8),
21    /// [serde::Serializer::serialize_i16]
22    I16(i16),
23    /// [serde::Serializer::serialize_i32]
24    I32(i32),
25    /// [serde::Serializer::serialize_i64]
26    I64(i64),
27
28    /// [serde::Serializer::serialize_u8]
29    U8(u8),
30    /// [serde::Serializer::serialize_u16]
31    U16(u16),
32    /// [serde::Serializer::serialize_u32]
33    U32(u32),
34    /// [serde::Serializer::serialize_u64]
35    U64(u64),
36
37    /// [serde::Serializer::serialize_f32]
38    F32(f32),
39    /// [serde::Serializer::serialize_f64]
40    F64(f64),
41
42    /// [serde::Serializer::serialize_char]
43    Char(char),
44    /// [serde::Serializer::serialize_str]
45    Str(String),
46    /// [serde::Serializer::serialize_bytes]
47    Bytes(Vec<u8>),
48
49    /// [serde::Serializer::serialize_none]
50    None,
51    /// [serde::Serializer::serialize_some]
52    Some(Box<Ast>),
53
54    /// [serde::Serializer::serialize_unit]
55    Unit,
56    /// [serde::Serializer::serialize_unit_struct]
57    UnitStruct(&'static str),
58    /// [serde::Serializer::serialize_unit_variant]
59    UnitVariant {
60        /// name
61        name: &'static str,
62        /// variant_index
63        variant_index: u32,
64        /// variant
65        variant: &'static str,
66    },
67
68    /// [serde::Serializer::serialize_newtype_struct]
69    NewtypeStruct {
70        /// name
71        name: &'static str,
72        /// value
73        value: Box<Ast>,
74    },
75    /// [serde::Serializer::serialize_newtype_variant]
76    NewtypeVariant {
77        /// name
78        name: &'static str,
79        /// variant_index
80        variant_index: u32,
81        /// variant
82        variant: &'static str,
83        /// value
84        value: Box<Ast>,
85    },
86
87    /// [serde::Serializer::serialize_seq]
88    Seq {
89        /// len
90        len: Option<usize>,
91        /// [serde::ser::SerializeSeq] operations
92        ops: Vec<Seq>,
93    },
94
95    /// [serde::Serializer::serialize_tuple]
96    Tuple {
97        /// len
98        len: usize,
99        /// [serde::ser::SerializeTuple] operations
100        ops: Vec<Tuple>,
101    },
102    /// [serde::Serializer::serialize_tuple_struct]
103    TupleStruct {
104        /// name
105        name: &'static str,
106        /// len
107        len: usize,
108        /// [serde::ser::SerializeTupleStruct] operations
109        ops: Vec<TupleStruct>,
110    },
111    /// [serde::Serializer::serialize_tuple_variant]
112    TupleVariant {
113        /// name
114        name: &'static str,
115        /// variant_index
116        variant_index: u32,
117        /// variant
118        variant: &'static str,
119        /// len
120        len: usize,
121        /// [serde::ser::SerializeTupleVariant] operations
122        ops: Vec<TupleVariant>,
123    },
124
125    /// [serde::Serializer::serialize_map]
126    Map {
127        /// len
128        len: Option<usize>,
129        /// [serde::ser::SerializeMap] operations
130        ops: Vec<Map>,
131    },
132    /// [serde::Serializer::serialize_struct]
133    Struct {
134        /// name
135        name: &'static str,
136        /// len
137        len: usize,
138        /// [serde::ser::SerializeStruct] operations
139        ops: Vec<Struct>,
140    },
141    /// [serde::Serializer::serialize_struct_variant]
142    StructVariant {
143        /// name
144        name: &'static str,
145        /// variant_index
146        variant_index: u32,
147        /// variant
148        variant: &'static str,
149        /// len
150        len: usize,
151        /// [serde::ser::SerializeStructVariant] operations
152        ops: Vec<StructVariant>,
153    },
154}
155impl Display for Ast {
156    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
157        write!(f, "{:#?}", self)
158    }
159}
160impl Serialize for Ast {
161    fn serialize<S>(&self, serializer: S) -> Result<S::Ok, S::Error>
162    where
163        S: serde::Serializer,
164    {
165        match self {
166            Ast::Bool(v) => serializer.serialize_bool(*v),
167            Ast::I8(v) => serializer.serialize_i8(*v),
168            Ast::I16(v) => serializer.serialize_i16(*v),
169            Ast::I32(v) => serializer.serialize_i32(*v),
170            Ast::I64(v) => serializer.serialize_i64(*v),
171            Ast::U8(v) => serializer.serialize_u8(*v),
172            Ast::U16(v) => serializer.serialize_u16(*v),
173            Ast::U32(v) => serializer.serialize_u32(*v),
174            Ast::U64(v) => serializer.serialize_u64(*v),
175            Ast::F32(v) => serializer.serialize_f32(*v),
176            Ast::F64(v) => serializer.serialize_f64(*v),
177            Ast::Char(v) => serializer.serialize_char(*v),
178            Ast::Str(v) => serializer.serialize_str(v),
179            Ast::Bytes(v) => serializer.serialize_bytes(v),
180            Ast::None => serializer.serialize_none(),
181            Ast::Some(v) => serializer.serialize_some(v),
182            Ast::Unit => serializer.serialize_unit(),
183            Ast::UnitStruct(name) => serializer.serialize_unit_struct(name),
184            Ast::UnitVariant {
185                name,
186                variant_index,
187                variant,
188            } => serializer.serialize_unit_variant(name, *variant_index, variant),
189            Ast::NewtypeStruct { name, value } => serializer.serialize_newtype_struct(name, value),
190            Ast::NewtypeVariant {
191                name,
192                variant_index,
193                variant,
194                value,
195            } => serializer.serialize_newtype_variant(name, *variant_index, variant, value),
196            Ast::Seq { len, ops } => {
197                let mut s = serializer.serialize_seq(*len)?;
198                for op in ops {
199                    match op {
200                        Seq::Element { value } => s.serialize_element(value)?,
201                    }
202                }
203                s.end()
204            }
205            Ast::Tuple { len, ops } => {
206                let mut s = serializer.serialize_tuple(*len)?;
207                for op in ops {
208                    match op {
209                        Tuple::Element { value } => s.serialize_element(value)?,
210                    }
211                }
212                s.end()
213            }
214            Ast::TupleStruct { name, len, ops } => {
215                let mut s = serializer.serialize_tuple_struct(name, *len)?;
216                for op in ops {
217                    match op {
218                        TupleStruct::Field { value } => s.serialize_field(value)?,
219                    }
220                }
221                s.end()
222            }
223            Ast::TupleVariant {
224                name,
225                variant_index,
226                variant,
227                len,
228                ops,
229            } => {
230                let mut s =
231                    serializer.serialize_tuple_variant(name, *variant_index, variant, *len)?;
232                for op in ops {
233                    match op {
234                        TupleVariant::Field { value } => s.serialize_field(value)?,
235                    }
236                }
237                s.end()
238            }
239            Ast::Map { len, ops } => {
240                let mut s = serializer.serialize_map(*len)?;
241                for op in ops {
242                    match op {
243                        Map::Key { key } => s.serialize_key(key)?,
244                        Map::Value { value } => s.serialize_value(value)?,
245                    }
246                }
247                s.end()
248            }
249            Ast::Struct { name, len, ops } => {
250                let mut s = serializer.serialize_struct(name, *len)?;
251                for op in ops {
252                    match op {
253                        Struct::Field { key, value } => s.serialize_field(key, value)?,
254                        Struct::Skip { key } => s.skip_field(key)?,
255                    }
256                }
257                s.end()
258            }
259            Ast::StructVariant {
260                name,
261                variant_index,
262                variant,
263                len,
264                ops,
265            } => {
266                let mut s =
267                    serializer.serialize_struct_variant(name, *variant_index, variant, *len)?;
268                for op in ops {
269                    match op {
270                        StructVariant::Field { key, value } => s.serialize_field(key, value)?,
271                        StructVariant::Skip { key } => s.skip_field(key)?,
272                    }
273                }
274                s.end()
275            }
276        }
277    }
278}
279
280/// [serde::ser::SerializeTuple]
281#[derive(Debug, Clone, PartialEq)]
282pub enum Tuple {
283    /// [serde::ser::SerializeTuple::serialize_element]
284    Element {
285        /// value
286        value: Box<Ast>,
287    },
288}
289
290/// [serde::ser::SerializeTupleStruct]
291#[derive(Debug, Clone, PartialEq)]
292pub enum TupleStruct {
293    /// [serde::ser::SerializeTupleStruct::serialize_field]
294    Field {
295        /// value
296        value: Box<Ast>,
297    },
298}
299
300/// [serde::ser::SerializeTupleVariant]
301#[derive(Debug, Clone, PartialEq)]
302pub enum TupleVariant {
303    /// [serde::ser::SerializeTupleVariant::serialize_field]
304    Field {
305        /// value
306        value: Box<Ast>,
307    },
308}
309
310/// [serde::ser::SerializeSeq]
311#[derive(Debug, Clone, PartialEq)]
312pub enum Seq {
313    /// [serde::ser::SerializeSeq::serialize_element]
314    Element {
315        /// value
316        value: Box<Ast>,
317    },
318}
319
320/// [serde::ser::SerializeMap]
321#[derive(Debug, Clone, PartialEq)]
322pub enum Map {
323    /// [serde::ser::SerializeMap::serialize_key]
324    Key {
325        /// key
326        key: Box<Ast>,
327    },
328    /// [serde::ser::SerializeMap::serialize_value]
329    Value {
330        /// value
331        value: Box<Ast>,
332    },
333}
334
335/// [serde::ser::SerializeStruct]
336#[derive(Debug, Clone, PartialEq)]
337pub enum Struct {
338    /// [serde::ser::SerializeStruct::serialize_field]
339    Field {
340        /// key
341        key: &'static str,
342        /// value
343        value: Box<Ast>,
344    },
345    /// [serde::ser::SerializeStruct::skip_field]
346    Skip {
347        /// key
348        key: &'static str,
349    },
350}
351
352/// [serde::ser::SerializeStructVariant]
353#[derive(Debug, Clone, PartialEq)]
354pub enum StructVariant {
355    /// [serde::ser::SerializeStructVariant::serialize_field]
356    Field {
357        /// key
358        key: &'static str,
359        /// value
360        value: Box<Ast>,
361    },
362    /// [serde::ser::SerializeStructVariant::skip_field]
363    Skip {
364        /// key
365        key: &'static str,
366    },
367}
serde_ast/ast.rs

serde_ast/
ast.rs
