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

cu29_value/
ser.rs
