cu29_value/
ser.rs

1use crate::Value;
2use core::error::Error;
3use core::fmt;
4use cu29_clock::CuTime;
5use serde::ser;
6
7use alloc::boxed::Box;
8use alloc::collections::BTreeMap;
9use alloc::string::{String, ToString};
10use alloc::vec;
11use alloc::vec::Vec;
12
13#[derive(Debug)]
14pub enum SerializerError {
15    Custom(String),
16}
17
18impl fmt::Display for SerializerError {
19    fn fmt(&self, fmt: &mut fmt::Formatter) -> fmt::Result {
20        match *self {
21            SerializerError::Custom(ref s) => fmt.write_str(s),
22        }
23    }
24}
25
26impl Error for SerializerError {
27    fn description(&self) -> &str {
28        "Value serializer error"
29    }
30}
31
32impl ser::Error for SerializerError {
33    fn custom<T: fmt::Display>(msg: T) -> SerializerError {
34        SerializerError::Custom(msg.to_string())
35    }
36}
37
38impl ser::Serialize for Value {
39    fn serialize<S: ser::Serializer>(&self, s: S) -> Result<S::Ok, S::Error> {
40        match *self {
41            Value::Bool(v) => s.serialize_newtype_struct("Value", &(self.discriminant() as u8, v)),
42            Value::U8(v) => s.serialize_newtype_struct("Value", &(self.discriminant() as u8, v)),
43            Value::U16(v) => s.serialize_newtype_struct("Value", &(self.discriminant() as u8, v)),
44            Value::U32(v) => s.serialize_newtype_struct("Value", &(self.discriminant() as u8, v)),
45            Value::U64(v) => s.serialize_newtype_struct("Value", &(self.discriminant() as u8, v)),
46            Value::I8(v) => s.serialize_newtype_struct("Value", &(self.discriminant() as u8, v)),
47            Value::I16(v) => s.serialize_newtype_struct("Value", &(self.discriminant() as u8, v)),
48            Value::I32(v) => s.serialize_newtype_struct("Value", &(self.discriminant() as u8, v)),
49            Value::I64(v) => s.serialize_newtype_struct("Value", &(self.discriminant() as u8, v)),
50            Value::F32(v) => s.serialize_newtype_struct("Value", &(self.discriminant() as u8, v)),
51            Value::F64(v) => s.serialize_newtype_struct("Value", &(self.discriminant() as u8, v)),
52            Value::Char(v) => s.serialize_newtype_struct("Value", &(self.discriminant() as u8, v)),
53            Value::String(ref v) => {
54                s.serialize_newtype_struct("Value", &(self.discriminant() as u8, v))
55            }
56            Value::Bytes(ref v) => {
57                s.serialize_newtype_struct("Value", &(self.discriminant() as u8, v))
58            }
59            Value::Unit => s.serialize_newtype_struct("Value", &(self.discriminant() as u8, ())),
60            Value::Option(None) => {
61                s.serialize_newtype_struct("Value", &(self.discriminant() as u8, ()))
62            }
63            Value::Option(Some(ref v)) => {
64                s.serialize_newtype_struct("Value", &(self.discriminant() as u8, v))
65            }
66            Value::Newtype(ref v) => {
67                s.serialize_newtype_struct("Value", &(self.discriminant() as u8, v))
68            }
69            Value::Seq(ref v) => v.serialize(s),
70            Value::Map(ref v) => v.serialize(s),
71            Value::CuTime(v) => {
72                s.serialize_newtype_struct("Value", &(self.discriminant() as u8, v))
73            }
74        }
75    }
76}
77
78pub fn to_value<T: ser::Serialize>(value: T) -> Result<Value, SerializerError> {
79    value.serialize(Serializer)
80}
81
82struct Serializer;
83
84impl ser::Serializer for Serializer {
85    type Ok = Value;
86    type Error = SerializerError;
87    type SerializeSeq = SerializeSeq;
88    type SerializeTuple = SerializeTuple;
89    type SerializeTupleStruct = SerializeTupleStruct;
90    type SerializeTupleVariant = SerializeTupleVariant;
91    type SerializeMap = SerializeMap;
92    type SerializeStruct = SerializeStruct;
93    type SerializeStructVariant = SerializeStructVariant;
94
95    fn serialize_bool(self, v: bool) -> Result<Self::Ok, Self::Error> {
96        Ok(Value::Bool(v))
97    }
98
99    fn serialize_i8(self, v: i8) -> Result<Self::Ok, Self::Error> {
100        Ok(Value::I8(v))
101    }
102
103    fn serialize_i16(self, v: i16) -> Result<Self::Ok, Self::Error> {
104        Ok(Value::I16(v))
105    }
106
107    fn serialize_i32(self, v: i32) -> Result<Self::Ok, Self::Error> {
108        Ok(Value::I32(v))
109    }
110
111    fn serialize_i64(self, v: i64) -> Result<Self::Ok, Self::Error> {
112        Ok(Value::I64(v))
113    }
114
115    fn serialize_u8(self, v: u8) -> Result<Self::Ok, Self::Error> {
116        Ok(Value::U8(v))
117    }
118
119    fn serialize_u16(self, v: u16) -> Result<Self::Ok, Self::Error> {
120        Ok(Value::U16(v))
121    }
122
123    fn serialize_u32(self, v: u32) -> Result<Self::Ok, Self::Error> {
124        Ok(Value::U32(v))
125    }
126
127    fn serialize_u64(self, v: u64) -> Result<Self::Ok, Self::Error> {
128        Ok(Value::U64(v))
129    }
130
131    fn serialize_f32(self, v: f32) -> Result<Self::Ok, Self::Error> {
132        Ok(Value::F32(v))
133    }
134
135    fn serialize_f64(self, v: f64) -> Result<Self::Ok, Self::Error> {
136        Ok(Value::F64(v))
137    }
138
139    fn serialize_char(self, v: char) -> Result<Self::Ok, Self::Error> {
140        Ok(Value::Char(v))
141    }
142
143    fn serialize_str(self, v: &str) -> Result<Self::Ok, Self::Error> {
144        Ok(Value::String(v.to_string()))
145    }
146
147    fn serialize_bytes(self, v: &[u8]) -> Result<Self::Ok, Self::Error> {
148        Ok(Value::Bytes(v.to_vec()))
149    }
150
151    fn serialize_none(self) -> Result<Self::Ok, Self::Error> {
152        Ok(Value::Option(None))
153    }
154
155    fn serialize_some<T: ?Sized + ser::Serialize>(
156        self,
157        value: &T,
158    ) -> Result<Self::Ok, Self::Error> {
159        value
160            .serialize(Serializer)
161            .map(|v| Value::Option(Some(Box::new(v))))
162    }
163
164    fn serialize_unit(self) -> Result<Self::Ok, Self::Error> {
165        Ok(Value::Unit)
166    }
167
168    fn serialize_unit_struct(self, _name: &'static str) -> Result<Self::Ok, Self::Error> {
169        Ok(Value::Unit)
170    }
171
172    fn serialize_unit_variant(
173        self,
174        _name: &'static str,
175        _variant_index: u32,
176        variant: &'static str,
177    ) -> Result<Self::Ok, Self::Error> {
178        Ok(Value::String(variant.to_string()))
179    }
180
181    fn serialize_newtype_struct<T: ?Sized + ser::Serialize>(
182        self,
183        name: &'static str,
184        value: &T,
185    ) -> Result<Self::Ok, Self::Error> {
186        if name == "CuDuration" || name == "CuTime" {
187            return value.serialize(Serializer).map(|v| {
188                if let Value::U64(v) = v {
189                    Value::CuTime(CuTime::from(v))
190                } else {
191                    v
192                }
193            });
194        }
195        value
196            .serialize(Serializer)
197            .map(|v| Value::Newtype(Box::new(v)))
198    }
199
200    fn serialize_newtype_variant<T: ?Sized + ser::Serialize>(
201        self,
202        _name: &'static str,
203        _variant_index: u32,
204        variant: &'static str,
205        value: &T,
206    ) -> Result<Self::Ok, Self::Error> {
207        value.serialize(Serializer).map(|v| {
208            let mut map = BTreeMap::new();
209            map.insert(Value::String(variant.to_string()), v);
210            Value::Map(map)
211        })
212    }
213
214    fn serialize_seq(self, _len: Option<usize>) -> Result<Self::SerializeSeq, Self::Error> {
215        Ok(SerializeSeq(vec![]))
216    }
217
218    fn serialize_tuple(self, _len: usize) -> Result<Self::SerializeTuple, Self::Error> {
219        Ok(SerializeTuple(vec![]))
220    }
221
222    fn serialize_tuple_struct(
223        self,
224        _name: &'static str,
225        _len: usize,
226    ) -> Result<Self::SerializeTupleStruct, Self::Error> {
227        Ok(SerializeTupleStruct(vec![]))
228    }
229
230    fn serialize_tuple_variant(
231        self,
232        _name: &'static str,
233        _variant_index: u32,
234        variant: &'static str,
235        len: usize,
236    ) -> Result<Self::SerializeTupleVariant, Self::Error> {
237        Ok(SerializeTupleVariant(
238            Value::String(variant.to_string()),
239            Vec::with_capacity(len),
240        ))
241    }
242
243    fn serialize_map(self, _len: Option<usize>) -> Result<Self::SerializeMap, Self::Error> {
244        Ok(SerializeMap {
245            map: BTreeMap::new(),
246            key: None,
247        })
248    }
249
250    fn serialize_struct(
251        self,
252        _name: &'static str,
253        _len: usize,
254    ) -> Result<Self::SerializeStruct, Self::Error> {
255        Ok(SerializeStruct(BTreeMap::new()))
256    }
257
258    fn serialize_struct_variant(
259        self,
260        _name: &'static str,
261        _variant_index: u32,
262        variant: &'static str,
263        _len: usize,
264    ) -> Result<Self::SerializeStructVariant, Self::Error> {
265        Ok(SerializeStructVariant(
266            Value::String(variant.to_string()),
267            BTreeMap::new(),
268        ))
269    }
270}
271
272struct SerializeSeq(Vec<Value>);
273
274impl ser::SerializeSeq for SerializeSeq {
275    type Ok = Value;
276    type Error = SerializerError;
277
278    fn serialize_element<T: ?Sized + ser::Serialize>(
279        &mut self,
280        value: &T,
281    ) -> Result<(), Self::Error> {
282        let Self(vec) = self;
283        let value = value.serialize(Serializer)?;
284        vec.push(value);
285        Ok(())
286    }
287
288    fn end(self) -> Result<Self::Ok, Self::Error> {
289        let Self(vec) = self;
290        Ok(Value::Seq(vec))
291    }
292}
293
294struct SerializeTuple(Vec<Value>);
295
296impl ser::SerializeTuple for SerializeTuple {
297    type Ok = Value;
298    type Error = SerializerError;
299
300    fn serialize_element<T: ?Sized + ser::Serialize>(
301        &mut self,
302        value: &T,
303    ) -> Result<(), Self::Error> {
304        let value = value.serialize(Serializer)?;
305        let Self(vec) = self;
306        vec.push(value);
307        Ok(())
308    }
309
310    fn end(self) -> Result<Self::Ok, Self::Error> {
311        let Self(vec) = self;
312        Ok(Value::Seq(vec))
313    }
314}
315
316struct SerializeTupleStruct(Vec<Value>);
317
318impl ser::SerializeTupleStruct for SerializeTupleStruct {
319    type Ok = Value;
320    type Error = SerializerError;
321
322    fn serialize_field<T: ?Sized + ser::Serialize>(
323        &mut self,
324        value: &T,
325    ) -> Result<(), Self::Error> {
326        let value = value.serialize(Serializer)?;
327        let Self(vec) = self;
328        vec.push(value);
329        Ok(())
330    }
331
332    fn end(self) -> Result<Self::Ok, Self::Error> {
333        let Self(vec) = self;
334        Ok(Value::Seq(vec))
335    }
336}
337
338struct SerializeTupleVariant(Value, Vec<Value>);
339
340impl ser::SerializeTupleVariant for SerializeTupleVariant {
341    type Ok = Value;
342    type Error = SerializerError;
343
344    fn serialize_field<T: ?Sized + ser::Serialize>(
345        &mut self,
346        value: &T,
347    ) -> Result<(), Self::Error> {
348        let value = value.serialize(Serializer)?;
349        self.1.push(value);
350        Ok(())
351    }
352
353    fn end(self) -> Result<Self::Ok, Self::Error> {
354        let mut map = BTreeMap::new();
355        let Self(key, value) = self;
356        map.insert(key, Value::Seq(value));
357        Ok(Value::Map(map))
358    }
359}
360
361struct SerializeMap {
362    map: BTreeMap<Value, Value>,
363    key: Option<Value>,
364}
365
366impl ser::SerializeMap for SerializeMap {
367    type Ok = Value;
368    type Error = SerializerError;
369
370    fn serialize_key<T: ?Sized + ser::Serialize>(&mut self, key: &T) -> Result<(), Self::Error> {
371        let key = key.serialize(Serializer)?;
372        self.key = Some(key);
373        Ok(())
374    }
375
376    fn serialize_value<T: ?Sized + ser::Serialize>(
377        &mut self,
378        value: &T,
379    ) -> Result<(), Self::Error> {
380        let value = value.serialize(Serializer)?;
381        self.map.insert(self.key.take().unwrap(), value);
382        Ok(())
383    }
384
385    fn end(self) -> Result<Self::Ok, Self::Error> {
386        Ok(Value::Map(self.map))
387    }
388}
389
390struct SerializeStruct(BTreeMap<Value, Value>);
391
392impl ser::SerializeStruct for SerializeStruct {
393    type Ok = Value;
394    type Error = SerializerError;
395
396    fn serialize_field<T: ?Sized + ser::Serialize>(
397        &mut self,
398        key: &'static str,
399        value: &T,
400    ) -> Result<(), Self::Error> {
401        let key = Value::String(key.to_string());
402        let value = value.serialize(Serializer)?;
403        let Self(map) = self;
404        map.insert(key, value);
405        Ok(())
406    }
407
408    fn end(self) -> Result<Self::Ok, Self::Error> {
409        let Self(map) = self;
410        Ok(Value::Map(map))
411    }
412}
413
414struct SerializeStructVariant(Value, BTreeMap<Value, Value>);
415
416impl ser::SerializeStructVariant for SerializeStructVariant {
417    type Ok = Value;
418    type Error = SerializerError;
419
420    fn serialize_field<T: ?Sized + ser::Serialize>(
421        &mut self,
422        key: &'static str,
423        value: &T,
424    ) -> Result<(), Self::Error> {
425        let key = Value::String(key.to_string());
426        let value = value.serialize(Serializer)?;
427        self.1.insert(key, value);
428        Ok(())
429    }
430
431    fn end(self) -> Result<Self::Ok, Self::Error> {
432        let mut map = BTreeMap::new();
433        let Self(key, value) = self;
434        map.insert(key, Value::Map(value));
435        Ok(Value::Map(map))
436    }
437}
cu29_value/ser.rs

cu29_value/
ser.rs
