serde_content/ser/
enum.rs

1use crate::ser::to_static_str;
2use crate::ser::Value;
3use crate::Data;
4use crate::Error;
5use crate::Serializer;
6use alloc::borrow::Cow;
7use alloc::boxed::Box;
8use alloc::collections::BTreeMap;
9use serde::ser;
10use serde::ser::SerializeMap;
11use serde::ser::SerializeStructVariant;
12use serde::ser::SerializeTupleVariant;
13
14pub struct Enum<'a> {
15    r#enum: crate::Enum<'a>,
16    human_readable: bool,
17}
18
19impl<'a> Enum<'a> {
20    pub(super) const fn new(r#enum: crate::Enum<'a>, human_readable: bool) -> Self {
21        Self {
22            r#enum,
23            human_readable,
24        }
25    }
26}
27
28impl ser::Serialize for crate::Enum<'_> {
29    fn serialize<S>(&self, serializer: S) -> Result<S::Ok, S::Error>
30    where
31        S: ser::Serializer,
32    {
33        match &self.data {
34            Data::Unit => match (&self.name, &self.variant) {
35                (Cow::Borrowed(name), Cow::Borrowed(variant)) => {
36                    serializer.serialize_unit_variant(name, self.variant_index, variant)
37                }
38                _ => serializer.serialize_str(self.variant.as_ref()),
39            },
40            Data::NewType { value } => match (&self.name, &self.variant) {
41                (Cow::Borrowed(name), Cow::Borrowed(variant)) => {
42                    serializer.serialize_newtype_variant(name, self.variant_index, variant, value)
43                }
44                _ => {
45                    let mut map = serializer.serialize_map(Some(1))?;
46                    map.serialize_entry(&self.variant, &value)?;
47                    map.end()
48                }
49            },
50            Data::Tuple { values } => match (&self.name, &self.variant) {
51                (Cow::Borrowed(name), Cow::Borrowed(variant)) => {
52                    let mut tup = serializer.serialize_tuple_variant(
53                        name,
54                        self.variant_index,
55                        variant,
56                        values.len(),
57                    )?;
58                    for value in values {
59                        tup.serialize_field(value)?;
60                    }
61                    tup.end()
62                }
63                _ => {
64                    let mut map = serializer.serialize_map(Some(1))?;
65                    map.serialize_entry(&self.variant, &values)?;
66                    map.end()
67                }
68            },
69            Data::Struct { fields } => match (&self.name, &self.variant) {
70                (Cow::Borrowed(name), Cow::Borrowed(variant)) => {
71                    let mut map = serializer.serialize_struct_variant(
72                        name,
73                        self.variant_index,
74                        variant,
75                        fields.len(),
76                    )?;
77                    for (key, value) in fields {
78                        let key = to_static_str(key)?;
79                        map.serialize_field(key, value)?;
80                    }
81                    map.end()
82                }
83                _ => {
84                    let mut btree = BTreeMap::new();
85                    for (key, value) in fields {
86                        btree.insert(key, value);
87                    }
88                    let mut map = serializer.serialize_map(Some(1))?;
89                    map.serialize_entry(&self.variant, &btree)?;
90                    map.end()
91                }
92            },
93        }
94    }
95}
96
97impl<'a> ser::SerializeStructVariant for Enum<'a> {
98    type Ok = Value<'a>;
99    type Error = Error;
100
101    fn serialize_field<T>(&mut self, key: &'static str, value: &T) -> Result<(), Error>
102    where
103        T: ?Sized + ser::Serialize,
104    {
105        if let Data::Struct { fields } = &mut self.r#enum.data {
106            let value = value.serialize(Serializer::with_human_readable(self.human_readable))?;
107            fields.push((Cow::Borrowed(key), value));
108        }
109        Ok(())
110    }
111
112    fn end(self) -> Result<Self::Ok, Error> {
113        Ok(Value::Enum(Box::new(self.r#enum)))
114    }
115}
116
117impl<'a> ser::SerializeTupleVariant for Enum<'a> {
118    type Ok = Value<'a>;
119    type Error = Error;
120
121    fn serialize_field<T>(&mut self, value: &T) -> Result<(), Error>
122    where
123        T: ?Sized + ser::Serialize,
124    {
125        if let Data::Tuple { values } = &mut self.r#enum.data {
126            let value = value.serialize(Serializer::with_human_readable(self.human_readable))?;
127            values.push(value);
128        }
129        Ok(())
130    }
131
132    fn end(self) -> Result<Self::Ok, Error> {
133        Ok(Value::Enum(Box::new(self.r#enum)))
134    }
135}
serde_content/ser/enum.rs

serde_content/ser/
enum.rs
