cu29_value/
ser.rs

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

cu29_value/
ser.rs
