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 value = value.serialize(Serializer)?;
278        self.0.push(value);
279        Ok(())
280    }
281
282    fn end(self) -> Result<Self::Ok, Self::Error> {
283        Ok(Value::Seq(self.0))
284    }
285}
286
287struct SerializeTuple(Vec<Value>);
288
289impl ser::SerializeTuple for SerializeTuple {
290    type Ok = Value;
291    type Error = SerializerError;
292
293    fn serialize_element<T: ?Sized + ser::Serialize>(
294        &mut self,
295        value: &T,
296    ) -> Result<(), Self::Error> {
297        let value = value.serialize(Serializer)?;
298        self.0.push(value);
299        Ok(())
300    }
301
302    fn end(self) -> Result<Self::Ok, Self::Error> {
303        Ok(Value::Seq(self.0))
304    }
305}
306
307struct SerializeTupleStruct(Vec<Value>);
308
309impl ser::SerializeTupleStruct for SerializeTupleStruct {
310    type Ok = Value;
311    type Error = SerializerError;
312
313    fn serialize_field<T: ?Sized + ser::Serialize>(
314        &mut self,
315        value: &T,
316    ) -> Result<(), Self::Error> {
317        let value = value.serialize(Serializer)?;
318        self.0.push(value);
319        Ok(())
320    }
321
322    fn end(self) -> Result<Self::Ok, Self::Error> {
323        Ok(Value::Seq(self.0))
324    }
325}
326
327struct SerializeTupleVariant(Value, Vec<Value>);
328
329impl ser::SerializeTupleVariant for SerializeTupleVariant {
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        self.1.push(value);
339        Ok(())
340    }
341
342    fn end(self) -> Result<Self::Ok, Self::Error> {
343        let mut map = BTreeMap::new();
344        map.insert(self.0, Value::Seq(self.1));
345        Ok(Value::Map(map))
346    }
347}
348
349struct SerializeMap {
350    map: BTreeMap<Value, Value>,
351    key: Option<Value>,
352}
353
354impl ser::SerializeMap for SerializeMap {
355    type Ok = Value;
356    type Error = SerializerError;
357
358    fn serialize_key<T: ?Sized + ser::Serialize>(&mut self, key: &T) -> Result<(), Self::Error> {
359        let key = key.serialize(Serializer)?;
360        self.key = Some(key);
361        Ok(())
362    }
363
364    fn serialize_value<T: ?Sized + ser::Serialize>(
365        &mut self,
366        value: &T,
367    ) -> Result<(), Self::Error> {
368        let value = value.serialize(Serializer)?;
369        self.map.insert(self.key.take().unwrap(), value);
370        Ok(())
371    }
372
373    fn end(self) -> Result<Self::Ok, Self::Error> {
374        Ok(Value::Map(self.map))
375    }
376}
377
378struct SerializeStruct(BTreeMap<Value, Value>);
379
380impl ser::SerializeStruct for SerializeStruct {
381    type Ok = Value;
382    type Error = SerializerError;
383
384    fn serialize_field<T: ?Sized + ser::Serialize>(
385        &mut self,
386        key: &'static str,
387        value: &T,
388    ) -> Result<(), Self::Error> {
389        let key = Value::String(key.to_string());
390        let value = value.serialize(Serializer)?;
391        self.0.insert(key, value);
392        Ok(())
393    }
394
395    fn end(self) -> Result<Self::Ok, Self::Error> {
396        Ok(Value::Map(self.0))
397    }
398}
399
400struct SerializeStructVariant(Value, BTreeMap<Value, Value>);
401
402impl ser::SerializeStructVariant for SerializeStructVariant {
403    type Ok = Value;
404    type Error = SerializerError;
405
406    fn serialize_field<T: ?Sized + ser::Serialize>(
407        &mut self,
408        key: &'static str,
409        value: &T,
410    ) -> Result<(), Self::Error> {
411        let key = Value::String(key.to_string());
412        let value = value.serialize(Serializer)?;
413        self.1.insert(key, value);
414        Ok(())
415    }
416
417    fn end(self) -> Result<Self::Ok, Self::Error> {
418        let mut map = BTreeMap::new();
419        map.insert(self.0, Value::Map(self.1));
420        Ok(Value::Map(map))
421    }
422}
cu29_value/ser.rs

cu29_value/
ser.rs
