step_p21/ast/
ser.rs

1use crate::{ast::*, error::*};
2use serde::ser;
3use std::convert::TryFrom;
4
5/// Serialize struct into STEP [Record]
6pub fn to_record(obj: &impl ser::Serialize) -> Result<Record> {
7    let mut ser = RecordSerializer::default();
8    obj.serialize(&mut ser)?;
9    assert!(ser.stack.is_empty()); // should panic because this must be bug, not a valid input
10    Ok(Record {
11        name: ser.name,
12        parameter: ser.parameters.iter().collect(),
13    })
14}
15
16#[derive(Default, Debug)]
17struct RecordSerializer {
18    name: String,
19    parameters: Vec<Parameter>,
20    // For supporting nested record e.g. `B(3.0, A((1.0, 2.0)))`
21    stack: Vec<(String, Vec<Parameter>)>,
22}
23
24impl ser::Serializer for &mut RecordSerializer {
25    type Error = Error;
26    type Ok = ();
27    type SerializeMap = Self;
28    type SerializeSeq = Self;
29    type SerializeStruct = Self;
30    type SerializeStructVariant = Self;
31    type SerializeTuple = Self;
32    type SerializeTupleStruct = Self;
33    type SerializeTupleVariant = Self;
34
35    fn serialize_bool(self, v: bool) -> Result<()> {
36        if v {
37            self.parameters
38                .push(Parameter::Enumeration("TRUE".to_string()));
39        } else {
40            self.parameters
41                .push(Parameter::Enumeration("FALSE".to_string()));
42        }
43        Ok(())
44    }
45
46    fn serialize_i8(self, v: i8) -> Result<()> {
47        self.serialize_i64(i64::from(v))
48    }
49
50    fn serialize_i16(self, v: i16) -> Result<()> {
51        self.serialize_i64(i64::from(v))
52    }
53
54    fn serialize_i32(self, v: i32) -> Result<()> {
55        self.serialize_i64(i64::from(v))
56    }
57
58    fn serialize_i64(self, v: i64) -> Result<()> {
59        self.parameters.push(Parameter::Integer(v));
60        Ok(())
61    }
62
63    fn serialize_u8(self, v: u8) -> Result<()> {
64        self.serialize_i64(i64::from(v))
65    }
66
67    fn serialize_u16(self, v: u16) -> Result<()> {
68        self.serialize_i64(i64::from(v))
69    }
70
71    fn serialize_u32(self, v: u32) -> Result<()> {
72        self.serialize_i64(i64::from(v))
73    }
74
75    fn serialize_u64(self, v: u64) -> Result<()> {
76        self.serialize_i64(
77            i64::try_from(v)
78                .expect("integer larger than i64::MAX is not supported"),
79        )
80    }
81
82    fn serialize_f32(self, v: f32) -> Result<()> {
83        self.serialize_f64(f64::from(v))
84    }
85
86    fn serialize_f64(self, v: f64) -> Result<()> {
87        self.parameters.push(Parameter::Real(v));
88        Ok(())
89    }
90
91    fn serialize_char(self, v: char) -> Result<()> {
92        self.serialize_str(&v.to_string())
93    }
94
95    fn serialize_str(self, v: &str) -> Result<()> {
96        self.parameters.push(Parameter::String(v.to_string()));
97        Ok(())
98    }
99
100    fn serialize_bytes(self, _v: &[u8]) -> Result<()> {
101        unimplemented!("Bytes is not supported yet")
102    }
103
104    fn serialize_none(self) -> Result<()> {
105        self.serialize_unit()
106    }
107
108    fn serialize_some<T>(self, value: &T) -> Result<()>
109    where
110        T: ?Sized + ser::Serialize,
111    {
112        value.serialize(self)
113    }
114
115    fn serialize_unit(self) -> Result<()> {
116        self.parameters.push(Parameter::NotProvided);
117        Ok(())
118    }
119
120    fn serialize_unit_struct(self, _name: &'static str) -> Result<()> {
121        self.serialize_unit()
122    }
123
124    fn serialize_unit_variant(
125        self,
126        _name: &'static str,
127        _variant_index: u32,
128        variant: &'static str,
129    ) -> Result<()> {
130        self.serialize_str(variant)
131    }
132
133    fn serialize_newtype_struct<T>(
134        self,
135        _name: &'static str,
136        value: &T,
137    ) -> Result<()>
138    where
139        T: ?Sized + ser::Serialize,
140    {
141        value.serialize(self)
142    }
143
144    fn serialize_newtype_variant<T>(
145        self,
146        _name: &'static str,
147        _variant_index: u32,
148        _variant: &'static str,
149        _value: &T,
150    ) -> Result<()>
151    where
152        T: ?Sized + ser::Serialize,
153    {
154        unimplemented!("Newtype variant is not suuported yet.")
155    }
156
157    fn serialize_seq(self, _len: Option<usize>) -> Result<Self::SerializeSeq> {
158        Ok(self)
159    }
160
161    fn serialize_tuple(self, len: usize) -> Result<Self::SerializeTuple> {
162        self.serialize_seq(Some(len))
163    }
164
165    fn serialize_tuple_struct(
166        self,
167        _name: &'static str,
168        len: usize,
169    ) -> Result<Self::SerializeTupleStruct> {
170        self.serialize_seq(Some(len))
171    }
172
173    fn serialize_tuple_variant(
174        self,
175        _name: &'static str,
176        _variant_index: u32,
177        _variant: &'static str,
178        _len: usize,
179    ) -> Result<Self::SerializeTupleVariant> {
180        unimplemented!("Tuple variant is not suuported yet.")
181    }
182
183    fn serialize_map(self, _len: Option<usize>) -> Result<Self::SerializeMap> {
184        Ok(self)
185    }
186
187    fn serialize_struct(
188        self,
189        name: &'static str,
190        _len: usize,
191    ) -> Result<Self::SerializeStruct> {
192        if self.name.is_empty() {
193            self.name = name.to_string();
194        } else {
195            // Entering sub struct e.g.
196            //
197            // ```
198            // B(3.0, A((1.0, 2.0))) ^ here
199            // ```
200            //
201            // Put current parameters (`3.0` as above) onto the top of stack,
202            // and start serializing `A((1.0, 2.0))`.
203            // This stack will be popped in SerializeStruct::end()
204            //
205            let current_name =
206                std::mem::replace(&mut self.name, name.to_string());
207            let current_params = std::mem::take(&mut self.parameters);
208            self.stack.push((current_name, current_params));
209        }
210        Ok(self)
211    }
212
213    fn serialize_struct_variant(
214        self,
215        _name: &'static str,
216        _variant_index: u32,
217        _variant: &'static str,
218        _len: usize,
219    ) -> Result<Self::SerializeStructVariant> {
220        unimplemented!("Struct variant is not suuported yet.")
221    }
222}
223
224impl ser::SerializeSeq for &mut RecordSerializer {
225    type Error = Error;
226    type Ok = ();
227
228    fn serialize_element<T>(&mut self, value: &T) -> Result<()>
229    where
230        T: ?Sized + ser::Serialize,
231    {
232        value.serialize(&mut **self)
233    }
234
235    fn end(self) -> Result<()> {
236        Ok(())
237    }
238}
239
240impl ser::SerializeTuple for &mut RecordSerializer {
241    type Error = Error;
242    type Ok = ();
243
244    fn serialize_element<T>(&mut self, value: &T) -> Result<()>
245    where
246        T: ?Sized + ser::Serialize,
247    {
248        value.serialize(&mut **self)
249    }
250
251    fn end(self) -> Result<()> {
252        Ok(())
253    }
254}
255
256impl ser::SerializeTupleStruct for &mut RecordSerializer {
257    type Error = Error;
258    type Ok = ();
259
260    fn serialize_field<T>(&mut self, value: &T) -> Result<()>
261    where
262        T: ?Sized + ser::Serialize,
263    {
264        value.serialize(&mut **self)
265    }
266
267    fn end(self) -> Result<()> {
268        Ok(())
269    }
270}
271
272impl ser::SerializeTupleVariant for &mut RecordSerializer {
273    type Error = Error;
274    type Ok = ();
275
276    fn serialize_field<T>(&mut self, value: &T) -> Result<()>
277    where
278        T: ?Sized + ser::Serialize,
279    {
280        value.serialize(&mut **self)
281    }
282
283    fn end(self) -> Result<()> {
284        Ok(())
285    }
286}
287
288impl ser::SerializeMap for &mut RecordSerializer {
289    type Error = Error;
290    type Ok = ();
291
292    fn serialize_key<T>(&mut self, _key: &T) -> Result<()>
293    where
294        T: ?Sized + ser::Serialize,
295    {
296        unimplemented!("Serialize Map to Record is not supported yet.")
297    }
298
299    fn serialize_value<T>(&mut self, _value: &T) -> Result<()>
300    where
301        T: ?Sized + ser::Serialize,
302    {
303        unimplemented!("Serialize Map to Record is not supported yet.")
304    }
305
306    fn end(self) -> Result<()> {
307        unimplemented!("Serialize Map to Record is not supported yet.")
308    }
309}
310
311impl ser::SerializeStruct for &mut RecordSerializer {
312    type Error = Error;
313    type Ok = ();
314
315    fn serialize_field<T>(
316        &mut self,
317        _key: &'static str,
318        value: &T,
319    ) -> Result<()>
320    where
321        T: ?Sized + ser::Serialize,
322    {
323        value.serialize(&mut **self)
324    }
325
326    fn end(self) -> Result<()> {
327        if let Some((name, params)) = self.stack.pop() {
328            // restore stacked state
329            let name = std::mem::replace(&mut self.name, name);
330            let params = std::mem::replace(&mut self.parameters, params);
331            self.parameters.push(Parameter::Typed {
332                keyword: name,
333                parameter: Box::new(params.into_iter().collect()),
334            });
335        }
336        Ok(())
337    }
338}
339
340impl ser::SerializeStructVariant for &mut RecordSerializer {
341    type Error = Error;
342    type Ok = ();
343
344    fn serialize_field<T>(
345        &mut self,
346        _key: &'static str,
347        value: &T,
348    ) -> Result<()>
349    where
350        T: ?Sized + ser::Serialize,
351    {
352        value.serialize(&mut **self)
353    }
354
355    fn end(self) -> Result<()> {
356        Ok(())
357    }
358}
step_p21/ast/ser.rs

step_p21/ast/
ser.rs
