mlang_rs/rt/serde/
ser.rs

1use crate::rt::opcode::{Path, Target, Variable};
2
3/// Serializer for Opcodes.
4pub trait Serializer {
5    type Error;
6    /// Type returns by [`serialize_el`](Serializer::serialize_el),
7    /// [`serialize_leaf`](Serializer::serialize_leaf) or [`serialize_attr`](Serializer::serialize_attr)
8    /// for serializing the content of node.
9    type SerializeNode: SerializeNode<Error = Self::Error>;
10
11    /// Returns by [`serialize_seq`](Serializer::serialize_seq) to help serializing array of vector.
12    type SerializeSeq: SerializeSeq<Error = Self::Error>;
13
14    /// Serialize a element node.
15    fn serialize_el(
16        self,
17        type_id: usize,
18        name: &str,
19        fields: usize,
20    ) -> Result<Self::SerializeNode, Self::Error>;
21
22    /// Serialize a leaf node.
23    fn serialize_leaf(
24        self,
25        type_id: usize,
26        name: &str,
27        fields: usize,
28    ) -> Result<Self::SerializeNode, Self::Error>;
29
30    /// Serialize a attr node.
31    fn serialize_attr(
32        self,
33        type_id: usize,
34        name: &str,
35        fields: usize,
36    ) -> Result<Self::SerializeNode, Self::Error>;
37
38    /// Serialize a data.
39    fn serialize_data(
40        self,
41        type_id: usize,
42        name: &str,
43        fields: usize,
44    ) -> Result<Self::SerializeNode, Self::Error>;
45
46    /// Serialize a enum data.
47    fn serialize_enum(
48        self,
49        type_id: usize,
50        name: &str,
51        variant: &str,
52        variant_index: usize,
53        fields: usize,
54    ) -> Result<Self::SerializeNode, Self::Error>;
55
56    /// Serialize vglang `vec[T]` or `[T;N]`
57    fn serialize_seq(self, len: usize) -> Result<Self::SerializeSeq, Self::Error>;
58
59    /// Serialize vglang `string`.
60    fn serialize_bool(self, value: bool) -> Result<(), Self::Error>;
61
62    /// Serialize vglang `string`.
63    fn serialize_string(self, value: &str) -> Result<(), Self::Error>;
64
65    /// Serialize vglang `byte`.
66    fn serialize_byte(self, value: i8) -> Result<(), Self::Error>;
67
68    /// Serialize vglang `ubyte`.
69    fn serialize_ubyte(self, value: u8) -> Result<(), Self::Error>;
70
71    /// Serialize vglang `byte`.
72    fn serialize_short(self, value: i16) -> Result<(), Self::Error>;
73
74    /// Serialize vglang `ubyte`.
75    fn serialize_ushort(self, value: u16) -> Result<(), Self::Error>;
76
77    /// Serialize vglang `int`.
78    fn serialize_int(self, value: i32) -> Result<(), Self::Error>;
79
80    /// Serialize vglang `uint`.
81    fn serialize_uint(self, value: u32) -> Result<(), Self::Error>;
82
83    /// Serialize vglang `long`.
84    fn serialize_long(self, value: i64) -> Result<(), Self::Error>;
85
86    /// Serialize vglang `ulong`.
87    fn serialize_ulong(self, value: u64) -> Result<(), Self::Error>;
88
89    /// Serialize vglang `long`.
90    fn serialize_float(self, value: f32) -> Result<(), Self::Error>;
91
92    /// Serialize vglang `double`.
93    fn serialize_double(self, value: f64) -> Result<(), Self::Error>;
94
95    /// Serialize a none value.
96    fn serialize_none(self) -> Result<(), Self::Error>;
97
98    /// Serialize a none value.
99    fn serialize_variable(self, path: &Path, target: &Target) -> Result<(), Self::Error>;
100
101    /// Serialize pop directive.
102    fn serialize_pop(self) -> Result<(), Self::Error>;
103}
104
105pub trait SerializeSeq {
106    type Error;
107
108    /// Serialize next item.
109    fn next_item<T>(&mut self, value: &T) -> Result<(), Self::Error>
110    where
111        T: ?Sized + Serialize;
112
113    /// Finish serializing a sequence.
114    fn finish(self) -> Result<(), Self::Error>;
115}
116
117/// A trait to help serialzing a node.
118pub trait SerializeNode {
119    /// Error type returns by this trait.
120    type Error;
121
122    /// Serialize a field.
123    fn serialize_field<T>(
124        &mut self,
125        index: usize,
126        name: Option<&str>,
127        value: &T,
128    ) -> Result<(), Self::Error>
129    where
130        T: ?Sized + Serialize;
131
132    /// Finish serializing a sequence.
133    fn finish(self) -> Result<(), Self::Error>;
134}
135
136/// A node/enum must implement this trait to support serde framework.
137pub trait Serialize {
138    /// serialize self with `serializer`.
139    fn serialize<S>(&self, serializer: S) -> Result<(), S::Error>
140    where
141        S: Serializer;
142}
143
144impl Serialize for bool {
145    fn serialize<S>(&self, serializer: S) -> Result<(), S::Error>
146    where
147        S: Serializer,
148    {
149        serializer.serialize_bool(*self)
150    }
151}
152
153impl Serialize for String {
154    fn serialize<S>(&self, serializer: S) -> Result<(), S::Error>
155    where
156        S: Serializer,
157    {
158        serializer.serialize_string(&self)
159    }
160}
161
162impl Serialize for i8 {
163    fn serialize<S>(&self, serializer: S) -> Result<(), S::Error>
164    where
165        S: Serializer,
166    {
167        serializer.serialize_byte(*self)
168    }
169}
170
171impl Serialize for u8 {
172    fn serialize<S>(&self, serializer: S) -> Result<(), S::Error>
173    where
174        S: Serializer,
175    {
176        serializer.serialize_ubyte(*self)
177    }
178}
179
180impl Serialize for i16 {
181    fn serialize<S>(&self, serializer: S) -> Result<(), S::Error>
182    where
183        S: Serializer,
184    {
185        serializer.serialize_short(*self)
186    }
187}
188
189impl Serialize for u16 {
190    fn serialize<S>(&self, serializer: S) -> Result<(), S::Error>
191    where
192        S: Serializer,
193    {
194        serializer.serialize_ushort(*self)
195    }
196}
197
198impl Serialize for i32 {
199    fn serialize<S>(&self, serializer: S) -> Result<(), S::Error>
200    where
201        S: Serializer,
202    {
203        serializer.serialize_int(*self)
204    }
205}
206
207impl Serialize for u32 {
208    fn serialize<S>(&self, serializer: S) -> Result<(), S::Error>
209    where
210        S: Serializer,
211    {
212        serializer.serialize_uint(*self)
213    }
214}
215
216impl Serialize for i64 {
217    fn serialize<S>(&self, serializer: S) -> Result<(), S::Error>
218    where
219        S: Serializer,
220    {
221        serializer.serialize_long(*self)
222    }
223}
224
225impl Serialize for u64 {
226    fn serialize<S>(&self, serializer: S) -> Result<(), S::Error>
227    where
228        S: Serializer,
229    {
230        serializer.serialize_ulong(*self)
231    }
232}
233
234impl Serialize for f32 {
235    fn serialize<S>(&self, serializer: S) -> Result<(), S::Error>
236    where
237        S: Serializer,
238    {
239        serializer.serialize_float(*self)
240    }
241}
242
243impl Serialize for f64 {
244    fn serialize<S>(&self, serializer: S) -> Result<(), S::Error>
245    where
246        S: Serializer,
247    {
248        serializer.serialize_double(*self)
249    }
250}
251
252impl<T> Serialize for Option<T>
253where
254    T: Serialize,
255{
256    fn serialize<S>(&self, serializer: S) -> Result<(), S::Error>
257    where
258        S: Serializer,
259    {
260        match self {
261            Some(v) => v.serialize(serializer),
262            None => serializer.serialize_none(),
263        }
264    }
265}
266
267impl<T> Serialize for Variable<T>
268where
269    T: Serialize,
270{
271    fn serialize<S>(&self, serializer: S) -> Result<(), S::Error>
272    where
273        S: Serializer,
274    {
275        match self {
276            Variable::Constant(v) => v.serialize(serializer),
277            Variable::Reference { path, target } => serializer.serialize_variable(path, target),
278        }
279    }
280}
281
282impl<T> Serialize for Vec<T>
283where
284    T: Serialize,
285{
286    fn serialize<S>(&self, serializer: S) -> Result<(), S::Error>
287    where
288        S: Serializer,
289    {
290        let mut seq = serializer.serialize_seq(self.len())?;
291
292        for item in self.iter() {
293            seq.next_item(item)?;
294        }
295
296        seq.finish()
297    }
298}
299
300impl<T, const N: usize> Serialize for [T; N]
301where
302    T: Serialize,
303{
304    fn serialize<S>(&self, serializer: S) -> Result<(), S::Error>
305    where
306        S: Serializer,
307    {
308        let mut seq = serializer.serialize_seq(self.len())?;
309
310        for item in self.iter() {
311            seq.next_item(item)?;
312        }
313
314        seq.finish()
315    }
316}
mlang_rs/rt/serde/ser.rs

mlang_rs/rt/serde/
ser.rs
