cu29_value/
ser.rs

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

cu29_value/
ser.rs
