serde_bridge/
ser.rs

1use indexmap::IndexMap;
2use serde::ser::{
3    SerializeMap, SerializeSeq, SerializeStruct, SerializeStructVariant, SerializeTuple,
4    SerializeTupleStruct, SerializeTupleVariant,
5};
6use serde::{ser, Serialize};
7
8use crate::{Error, Value};
9
10/// Convert `T: Serialize` into [`Value`].
11///
12/// # Examples
13///
14/// ```
15/// use serde_bridge::{into_value, Value};
16/// # use anyhow::Result;
17/// # fn main() -> Result<()>{
18/// let v = into_value(true)?;
19/// # assert_eq!(v, Value::Bool(true));
20/// # Ok(())
21/// # }
22/// ```
23pub fn into_value(v: impl Serialize) -> Result<Value, Error> {
24    v.serialize(Serializer)
25}
26
27/// Convert `T: Serialize` into [`Value`].
28///
29/// # Examples
30///
31/// ```
32/// use serde_bridge::{IntoValue, Value};
33/// # use anyhow::Result;
34/// # fn main() -> Result<()>{
35/// let v = true.into_value()?;
36/// # assert_eq!(v, Value::Bool(true));
37/// # Ok(())
38/// # }
39/// ```
40pub trait IntoValue {
41    fn into_value(self) -> Result<Value, Error>;
42}
43
44impl<T> IntoValue for T
45where
46    T: Serialize,
47{
48    fn into_value(self) -> Result<Value, Error> {
49        into_value(self)
50    }
51}
52
53/// Implement transparent [`serde::Serialize`](https://docs.serde.rs/serde/trait.Serialize.html) for [`Value`].
54///
55/// `Serialize` on `Value` that converted from `T` will be the same with `T`.
56impl serde::Serialize for Value {
57    fn serialize<S>(&self, s: S) -> Result<S::Ok, S::Error>
58    where
59        S: serde::Serializer,
60    {
61        match self {
62            Value::Bool(v) => s.serialize_bool(*v),
63            Value::I8(v) => s.serialize_i8(*v),
64            Value::I16(v) => s.serialize_i16(*v),
65            Value::I32(v) => s.serialize_i32(*v),
66            Value::I64(v) => s.serialize_i64(*v),
67            Value::I128(v) => s.serialize_i128(*v),
68            Value::U8(v) => s.serialize_u8(*v),
69            Value::U16(v) => s.serialize_u16(*v),
70            Value::U32(v) => s.serialize_u32(*v),
71            Value::U64(v) => s.serialize_u64(*v),
72            Value::U128(v) => s.serialize_u128(*v),
73            Value::F32(v) => s.serialize_f32(*v),
74            Value::F64(v) => s.serialize_f64(*v),
75            Value::Char(v) => s.serialize_char(*v),
76            Value::Str(v) => s.serialize_str(v),
77            Value::Bytes(v) => s.serialize_bytes(v),
78            Value::None => s.serialize_none(),
79            Value::Some(v) => s.serialize_some(v),
80            Value::Unit => s.serialize_unit(),
81            Value::UnitStruct(name) => s.serialize_unit_struct(name),
82            Value::UnitVariant {
83                name,
84                variant_index,
85                variant,
86            } => s.serialize_unit_variant(name, *variant_index, variant),
87            Value::NewtypeStruct(name, value) => s.serialize_newtype_struct(name, value),
88            Value::NewtypeVariant {
89                name,
90                variant_index,
91                variant,
92                value,
93            } => s.serialize_newtype_variant(name, *variant_index, variant, value),
94            Value::Seq(v) => {
95                let mut seq = s.serialize_seq(Some(v.len()))?;
96                for i in v {
97                    seq.serialize_element(i)?;
98                }
99                seq.end()
100            }
101            Value::Tuple(v) => {
102                let mut tuple = s.serialize_tuple(v.len())?;
103                for i in v {
104                    tuple.serialize_element(i)?;
105                }
106                tuple.end()
107            }
108            Value::TupleStruct(name, fields) => {
109                let mut se = s.serialize_tuple_struct(name, fields.len())?;
110                for i in fields {
111                    se.serialize_field(i)?;
112                }
113                se.end()
114            }
115            Value::TupleVariant {
116                name,
117                variant_index,
118                variant,
119                fields,
120            } => {
121                let mut se =
122                    s.serialize_tuple_variant(name, *variant_index, variant, fields.len())?;
123                for i in fields {
124                    se.serialize_field(i)?;
125                }
126                se.end()
127            }
128            Value::Map(map) => {
129                let mut se = s.serialize_map(Some(map.len()))?;
130                for (k, v) in map {
131                    se.serialize_entry(k, v)?;
132                }
133                se.end()
134            }
135            Value::Struct(name, fields) => {
136                let mut se = s.serialize_struct(name, fields.len())?;
137                for (k, v) in fields {
138                    se.serialize_field(k, v)?;
139                }
140                se.end()
141            }
142            Value::StructVariant {
143                name,
144                variant_index,
145                variant,
146                fields,
147            } => {
148                let mut se =
149                    s.serialize_struct_variant(name, *variant_index, variant, fields.len())?;
150                for (k, v) in fields {
151                    se.serialize_field(k, v)?;
152                }
153                se.end()
154            }
155        }
156    }
157}
158
159struct Serializer;
160
161impl serde::Serializer for Serializer {
162    type Ok = Value;
163    type Error = Error;
164    type SerializeSeq = SeqSerializer;
165    type SerializeTuple = TupleSerializer;
166    type SerializeTupleStruct = TupleStructSerializer;
167    type SerializeTupleVariant = TupleVariantSerializer;
168    type SerializeMap = MapSerializer;
169    type SerializeStruct = StructSerializer;
170    type SerializeStructVariant = StructVariantSerializer;
171
172    fn serialize_bool(self, v: bool) -> Result<Self::Ok, Self::Error> {
173        Ok(Value::Bool(v))
174    }
175
176    fn serialize_i8(self, v: i8) -> Result<Self::Ok, Self::Error> {
177        Ok(Value::I8(v))
178    }
179
180    fn serialize_i16(self, v: i16) -> Result<Self::Ok, Self::Error> {
181        Ok(Value::I16(v))
182    }
183
184    fn serialize_i32(self, v: i32) -> Result<Self::Ok, Self::Error> {
185        Ok(Value::I32(v))
186    }
187
188    fn serialize_i64(self, v: i64) -> Result<Self::Ok, Self::Error> {
189        Ok(Value::I64(v))
190    }
191
192    fn serialize_u8(self, v: u8) -> Result<Self::Ok, Self::Error> {
193        Ok(Value::U8(v))
194    }
195
196    fn serialize_u16(self, v: u16) -> Result<Self::Ok, Self::Error> {
197        Ok(Value::U16(v))
198    }
199
200    fn serialize_u32(self, v: u32) -> Result<Self::Ok, Self::Error> {
201        Ok(Value::U32(v))
202    }
203
204    fn serialize_u64(self, v: u64) -> Result<Self::Ok, Self::Error> {
205        Ok(Value::U64(v))
206    }
207
208    fn serialize_f32(self, v: f32) -> Result<Self::Ok, Self::Error> {
209        Ok(Value::F32(v))
210    }
211
212    fn serialize_f64(self, v: f64) -> Result<Self::Ok, Self::Error> {
213        Ok(Value::F64(v))
214    }
215
216    fn serialize_char(self, v: char) -> Result<Self::Ok, Self::Error> {
217        Ok(Value::Char(v))
218    }
219
220    fn serialize_str(self, v: &str) -> Result<Self::Ok, Self::Error> {
221        Ok(Value::Str(v.to_string()))
222    }
223
224    fn serialize_bytes(self, v: &[u8]) -> Result<Self::Ok, Self::Error> {
225        Ok(Value::Bytes(v.to_vec()))
226    }
227
228    fn serialize_none(self) -> Result<Self::Ok, Self::Error> {
229        Ok(Value::None)
230    }
231
232    fn serialize_some<T: ?Sized + Serialize>(self, value: &T) -> Result<Self::Ok, Self::Error> {
233        Ok(Value::Some(Box::new(value.serialize(Serializer)?)))
234    }
235
236    fn serialize_unit(self) -> Result<Self::Ok, Self::Error> {
237        Ok(Value::Unit)
238    }
239
240    fn serialize_unit_struct(self, name: &'static str) -> Result<Self::Ok, Self::Error> {
241        Ok(Value::UnitStruct(name))
242    }
243
244    fn serialize_unit_variant(
245        self,
246        name: &'static str,
247        variant_index: u32,
248        variant: &'static str,
249    ) -> Result<Self::Ok, Self::Error> {
250        Ok(Value::UnitVariant {
251            name,
252            variant_index,
253            variant,
254        })
255    }
256
257    fn serialize_newtype_struct<T: ?Sized + Serialize>(
258        self,
259        name: &'static str,
260        value: &T,
261    ) -> Result<Self::Ok, Self::Error> {
262        Ok(Value::NewtypeStruct(
263            name,
264            Box::new(value.serialize(Serializer)?),
265        ))
266    }
267
268    fn serialize_newtype_variant<T: ?Sized + Serialize>(
269        self,
270        name: &'static str,
271        variant_index: u32,
272        variant: &'static str,
273        value: &T,
274    ) -> Result<Self::Ok, Self::Error> {
275        Ok(Value::NewtypeVariant {
276            name,
277            variant_index,
278            variant,
279            value: Box::new(value.serialize(Serializer)?),
280        })
281    }
282
283    fn serialize_seq(self, len: Option<usize>) -> Result<Self::SerializeSeq, Self::Error> {
284        Ok(SeqSerializer::new(len))
285    }
286
287    fn serialize_tuple(self, len: usize) -> Result<Self::SerializeTuple, Self::Error> {
288        Ok(TupleSerializer::new(len))
289    }
290
291    fn serialize_tuple_struct(
292        self,
293        name: &'static str,
294        len: usize,
295    ) -> Result<Self::SerializeTupleStruct, Self::Error> {
296        Ok(TupleStructSerializer::new(name, len))
297    }
298
299    fn serialize_tuple_variant(
300        self,
301        name: &'static str,
302        variant_index: u32,
303        variant: &'static str,
304        len: usize,
305    ) -> Result<Self::SerializeTupleVariant, Self::Error> {
306        Ok(TupleVariantSerializer::new(
307            name,
308            variant_index,
309            variant,
310            len,
311        ))
312    }
313
314    fn serialize_map(self, len: Option<usize>) -> Result<Self::SerializeMap, Self::Error> {
315        Ok(MapSerializer::new(len))
316    }
317
318    fn serialize_struct(
319        self,
320        name: &'static str,
321        len: usize,
322    ) -> Result<Self::SerializeStruct, Self::Error> {
323        Ok(StructSerializer::new(name, len))
324    }
325
326    fn serialize_struct_variant(
327        self,
328        name: &'static str,
329        variant_index: u32,
330        variant: &'static str,
331        len: usize,
332    ) -> Result<Self::SerializeStructVariant, Self::Error> {
333        Ok(StructVariantSerializer::new(
334            name,
335            variant_index,
336            variant,
337            len,
338        ))
339    }
340}
341
342struct SeqSerializer {
343    elements: Vec<Value>,
344}
345
346impl SeqSerializer {
347    pub fn new(len: Option<usize>) -> Self {
348        Self {
349            elements: Vec::with_capacity(len.unwrap_or_default()),
350        }
351    }
352}
353
354impl ser::SerializeSeq for SeqSerializer {
355    type Ok = Value;
356    type Error = Error;
357
358    fn serialize_element<T: ?Sized + Serialize>(&mut self, value: &T) -> Result<(), Self::Error> {
359        self.elements.push(value.serialize(Serializer)?);
360
361        Ok(())
362    }
363
364    fn end(self) -> Result<Self::Ok, Self::Error> {
365        Ok(Value::Seq(self.elements))
366    }
367}
368
369struct TupleSerializer {
370    elements: Vec<Value>,
371}
372
373impl TupleSerializer {
374    pub fn new(len: usize) -> Self {
375        Self {
376            elements: Vec::with_capacity(len),
377        }
378    }
379}
380
381impl ser::SerializeTuple for TupleSerializer {
382    type Ok = Value;
383    type Error = Error;
384
385    fn serialize_element<T: ?Sized + Serialize>(&mut self, value: &T) -> Result<(), Self::Error> {
386        self.elements.push(value.serialize(Serializer)?);
387
388        Ok(())
389    }
390
391    fn end(self) -> Result<Self::Ok, Self::Error> {
392        Ok(Value::Tuple(self.elements))
393    }
394}
395
396struct TupleStructSerializer {
397    name: &'static str,
398    fields: Vec<Value>,
399}
400
401impl TupleStructSerializer {
402    pub fn new(name: &'static str, len: usize) -> Self {
403        Self {
404            name,
405            fields: Vec::with_capacity(len),
406        }
407    }
408}
409
410impl ser::SerializeTupleStruct for TupleStructSerializer {
411    type Ok = Value;
412    type Error = Error;
413
414    fn serialize_field<T: ?Sized + Serialize>(&mut self, value: &T) -> Result<(), Self::Error> {
415        self.fields.push(value.serialize(Serializer)?);
416
417        Ok(())
418    }
419
420    fn end(self) -> Result<Self::Ok, Self::Error> {
421        Ok(Value::TupleStruct(self.name, self.fields))
422    }
423}
424
425struct TupleVariantSerializer {
426    name: &'static str,
427    variant_index: u32,
428    variant: &'static str,
429    fields: Vec<Value>,
430}
431
432impl TupleVariantSerializer {
433    pub fn new(name: &'static str, variant_index: u32, variant: &'static str, len: usize) -> Self {
434        Self {
435            name,
436            variant_index,
437            variant,
438            fields: Vec::with_capacity(len),
439        }
440    }
441}
442
443impl ser::SerializeTupleVariant for TupleVariantSerializer {
444    type Ok = Value;
445    type Error = Error;
446
447    fn serialize_field<T: ?Sized + Serialize>(&mut self, value: &T) -> Result<(), Self::Error> {
448        self.fields.push(value.serialize(Serializer)?);
449
450        Ok(())
451    }
452
453    fn end(self) -> Result<Self::Ok, Self::Error> {
454        Ok(Value::TupleVariant {
455            name: self.name,
456            variant_index: self.variant_index,
457            variant: self.variant,
458            fields: self.fields,
459        })
460    }
461}
462
463struct MapSerializer {
464    cache_key: Option<Value>,
465    entries: IndexMap<Value, Value>,
466}
467
468impl MapSerializer {
469    pub fn new(len: Option<usize>) -> Self {
470        Self {
471            cache_key: None,
472            entries: IndexMap::with_capacity(len.unwrap_or_default()),
473        }
474    }
475}
476
477impl ser::SerializeMap for MapSerializer {
478    type Ok = Value;
479    type Error = Error;
480
481    fn serialize_key<T: ?Sized + Serialize>(&mut self, key: &T) -> Result<(), Self::Error> {
482        debug_assert!(
483            self.cache_key.is_none(),
484            "value for the last entry is missing"
485        );
486        self.cache_key = Some(key.serialize(Serializer)?);
487
488        Ok(())
489    }
490
491    fn serialize_value<T: ?Sized + Serialize>(&mut self, value: &T) -> Result<(), Self::Error> {
492        let key = self
493            .cache_key
494            .take()
495            .expect("key for current entry is missing");
496        self.entries.insert(key, value.serialize(Serializer)?);
497
498        Ok(())
499    }
500
501    fn end(self) -> Result<Self::Ok, Self::Error> {
502        Ok(Value::Map(self.entries))
503    }
504}
505
506struct StructSerializer {
507    name: &'static str,
508    fields: IndexMap<&'static str, Value>,
509}
510
511impl StructSerializer {
512    pub fn new(name: &'static str, len: usize) -> Self {
513        Self {
514            name,
515            fields: IndexMap::with_capacity(len),
516        }
517    }
518}
519
520impl ser::SerializeStruct for StructSerializer {
521    type Ok = Value;
522    type Error = Error;
523
524    fn serialize_field<T: ?Sized + Serialize>(
525        &mut self,
526        key: &'static str,
527        value: &T,
528    ) -> Result<(), Self::Error> {
529        self.fields.insert(key, value.serialize(Serializer)?);
530
531        Ok(())
532    }
533
534    fn end(self) -> Result<Self::Ok, Self::Error> {
535        Ok(Value::Struct(self.name, self.fields))
536    }
537}
538
539struct StructVariantSerializer {
540    name: &'static str,
541    variant_index: u32,
542    variant: &'static str,
543    fields: IndexMap<&'static str, Value>,
544}
545
546impl StructVariantSerializer {
547    pub fn new(name: &'static str, variant_index: u32, variant: &'static str, len: usize) -> Self {
548        Self {
549            name,
550            variant_index,
551            variant,
552            fields: IndexMap::with_capacity(len),
553        }
554    }
555}
556
557impl ser::SerializeStructVariant for StructVariantSerializer {
558    type Ok = Value;
559    type Error = Error;
560
561    fn serialize_field<T: ?Sized + Serialize>(
562        &mut self,
563        key: &'static str,
564        value: &T,
565    ) -> Result<(), Self::Error> {
566        self.fields.insert(key, value.serialize(Serializer)?);
567
568        Ok(())
569    }
570
571    fn end(self) -> Result<Self::Ok, Self::Error> {
572        Ok(Value::StructVariant {
573            name: self.name,
574            variant_index: self.variant_index,
575            variant: self.variant,
576            fields: self.fields,
577        })
578    }
579}
580
581#[cfg(test)]
582mod tests {
583    use anyhow::Result;
584    use indexmap::indexmap;
585
586    use super::*;
587
588    #[derive(serde::Serialize)]
589    struct TestStruct {
590        a: bool,
591        b: i32,
592        c: u64,
593        d: String,
594        e: f64,
595    }
596
597    #[test]
598    fn test_to_value() {
599        assert_eq!(into_value(128).expect("must success"), Value::I32(128));
600        assert_eq!(into_value(128_u64).expect("must success"), Value::U64(128));
601
602        assert_eq!(
603            into_value(TestStruct {
604                a: true,
605                b: 1,
606                c: 2,
607                d: "Hello, World!".to_string(),
608                e: 4.5
609            })
610            .expect("must success"),
611            Value::Struct(
612                "TestStruct",
613                indexmap! {
614                    "a" => Value::Bool(true),
615                    "b" => Value::I32(1),
616                    "c" => Value::U64(2),
617                    "d" => Value::Str("Hello, World!".to_string()),
618                    "e" => Value::F64(4.5)
619                }
620            )
621        )
622    }
623
624    #[test]
625    fn test_serialize() -> Result<()> {
626        let raw = TestStruct {
627            a: true,
628            b: 1,
629            c: 2,
630            d: "Hello, World!".to_string(),
631            e: 4.5,
632        };
633        let value = Value::Struct(
634            "TestStruct",
635            indexmap! {
636                "a" => Value::Bool(true),
637                "b" => Value::I32(1),
638                "c" => Value::U64(2),
639                "d" => Value::Str("Hello, World!".to_string()),
640                "e" => Value::F64(4.5)
641            },
642        );
643
644        assert_eq!(serde_json::to_string(&raw)?, serde_json::to_string(&value)?);
645
646        Ok(())
647    }
648}
serde_bridge/ser.rs

serde_bridge/
ser.rs
