toml_edit/ser/
value.rs

1use super::Error;
2
3/// Serialization for TOML [values][crate::Value].
4///
5/// This structure implements serialization support for TOML to serialize an
6/// arbitrary type to TOML. Note that the TOML format does not support all
7/// datatypes in Rust, such as enums, tuples, and tuple structs. These types
8/// will generate an error when serialized.
9///
10/// Currently a serializer always writes its output to an in-memory `String`,
11/// which is passed in when creating the serializer itself.
12///
13/// # Examples
14///
15/// ```
16/// use serde::Serialize;
17///
18/// #[derive(Serialize)]
19/// struct Config {
20///     database: Database,
21/// }
22///
23/// #[derive(Serialize)]
24/// struct Database {
25///     ip: String,
26///     port: Vec<u16>,
27///     connection_max: u32,
28///     enabled: bool,
29/// }
30///
31/// let config = Config {
32///     database: Database {
33///         ip: "192.168.1.1".to_string(),
34///         port: vec![8001, 8002, 8003],
35///         connection_max: 5000,
36///         enabled: false,
37///     },
38/// };
39///
40/// let value = serde::Serialize::serialize(
41///     &config,
42///     toml_edit::ser::ValueSerializer::new()
43/// ).unwrap();
44/// println!("{}", value)
45/// ```
46#[derive(Default)]
47#[non_exhaustive]
48pub struct ValueSerializer {}
49
50impl ValueSerializer {
51    /// Creates a new serializer generate a TOML document.
52    pub fn new() -> Self {
53        Self {}
54    }
55}
56
57impl serde::ser::Serializer for ValueSerializer {
58    type Ok = crate::Value;
59    type Error = Error;
60    type SerializeSeq = super::SerializeValueArray;
61    type SerializeTuple = super::SerializeValueArray;
62    type SerializeTupleStruct = super::SerializeValueArray;
63    type SerializeTupleVariant = super::SerializeValueArray;
64    type SerializeMap = super::SerializeMap;
65    type SerializeStruct = super::SerializeMap;
66    type SerializeStructVariant = serde::ser::Impossible<Self::Ok, Self::Error>;
67
68    fn serialize_bool(self, v: bool) -> Result<Self::Ok, Self::Error> {
69        Ok(v.into())
70    }
71
72    fn serialize_i8(self, v: i8) -> Result<Self::Ok, Self::Error> {
73        self.serialize_i64(v as i64)
74    }
75
76    fn serialize_i16(self, v: i16) -> Result<Self::Ok, Self::Error> {
77        self.serialize_i64(v as i64)
78    }
79
80    fn serialize_i32(self, v: i32) -> Result<Self::Ok, Self::Error> {
81        self.serialize_i64(v as i64)
82    }
83
84    fn serialize_i64(self, v: i64) -> Result<Self::Ok, Self::Error> {
85        Ok(v.into())
86    }
87
88    fn serialize_u8(self, v: u8) -> Result<Self::Ok, Self::Error> {
89        self.serialize_i64(v as i64)
90    }
91
92    fn serialize_u16(self, v: u16) -> Result<Self::Ok, Self::Error> {
93        self.serialize_i64(v as i64)
94    }
95
96    fn serialize_u32(self, v: u32) -> Result<Self::Ok, Self::Error> {
97        self.serialize_i64(v as i64)
98    }
99
100    fn serialize_u64(self, v: u64) -> Result<Self::Ok, Self::Error> {
101        self.serialize_i64(v as i64)
102    }
103
104    fn serialize_f32(self, v: f32) -> Result<Self::Ok, Self::Error> {
105        self.serialize_f64(v as f64)
106    }
107
108    fn serialize_f64(self, v: f64) -> Result<Self::Ok, Self::Error> {
109        Ok(v.into())
110    }
111
112    fn serialize_char(self, v: char) -> Result<Self::Ok, Self::Error> {
113        let mut buf = [0; 4];
114        self.serialize_str(v.encode_utf8(&mut buf))
115    }
116
117    fn serialize_str(self, v: &str) -> Result<Self::Ok, Self::Error> {
118        Ok(v.into())
119    }
120
121    fn serialize_bytes(self, value: &[u8]) -> Result<Self::Ok, Self::Error> {
122        use serde::ser::Serialize;
123        value.serialize(self)
124    }
125
126    fn serialize_none(self) -> Result<Self::Ok, Self::Error> {
127        Err(Error::UnsupportedNone)
128    }
129
130    fn serialize_some<T: ?Sized>(self, value: &T) -> Result<Self::Ok, Self::Error>
131    where
132        T: serde::ser::Serialize,
133    {
134        value.serialize(self)
135    }
136
137    fn serialize_unit(self) -> Result<Self::Ok, Self::Error> {
138        Err(Error::UnsupportedType(Some("unit")))
139    }
140
141    fn serialize_unit_struct(self, name: &'static str) -> Result<Self::Ok, Self::Error> {
142        Err(Error::UnsupportedType(Some(name)))
143    }
144
145    fn serialize_unit_variant(
146        self,
147        _name: &'static str,
148        _variant_index: u32,
149        variant: &'static str,
150    ) -> Result<Self::Ok, Self::Error> {
151        self.serialize_str(variant)
152    }
153
154    fn serialize_newtype_struct<T: ?Sized>(
155        self,
156        _name: &'static str,
157        value: &T,
158    ) -> Result<Self::Ok, Self::Error>
159    where
160        T: serde::ser::Serialize,
161    {
162        value.serialize(self)
163    }
164
165    fn serialize_newtype_variant<T: ?Sized>(
166        self,
167        name: &'static str,
168        _variant_index: u32,
169        _variant: &'static str,
170        _value: &T,
171    ) -> Result<Self::Ok, Self::Error>
172    where
173        T: serde::ser::Serialize,
174    {
175        Err(Error::UnsupportedType(Some(name)))
176    }
177
178    fn serialize_seq(self, len: Option<usize>) -> Result<Self::SerializeSeq, Self::Error> {
179        let serializer = match len {
180            Some(len) => super::SerializeValueArray::with_capacity(len),
181            None => super::SerializeValueArray::new(),
182        };
183        Ok(serializer)
184    }
185
186    fn serialize_tuple(self, len: usize) -> Result<Self::SerializeTuple, Self::Error> {
187        self.serialize_seq(Some(len))
188    }
189
190    fn serialize_tuple_struct(
191        self,
192        _name: &'static str,
193        len: usize,
194    ) -> Result<Self::SerializeTupleStruct, Self::Error> {
195        self.serialize_seq(Some(len))
196    }
197
198    fn serialize_tuple_variant(
199        self,
200        _name: &'static str,
201        _variant_index: u32,
202        _variant: &'static str,
203        len: usize,
204    ) -> Result<Self::SerializeTupleVariant, Self::Error> {
205        self.serialize_seq(Some(len))
206    }
207
208    fn serialize_map(self, len: Option<usize>) -> Result<Self::SerializeMap, Self::Error> {
209        let serializer = match len {
210            Some(len) => super::SerializeMap::table_with_capacity(len),
211            None => super::SerializeMap::table(),
212        };
213        Ok(serializer)
214    }
215
216    fn serialize_struct(
217        self,
218        name: &'static str,
219        len: usize,
220    ) -> Result<Self::SerializeStruct, Self::Error> {
221        if name == toml_datetime::__unstable::NAME {
222            Ok(super::SerializeMap::datetime())
223        } else {
224            self.serialize_map(Some(len))
225        }
226    }
227
228    fn serialize_struct_variant(
229        self,
230        name: &'static str,
231        _variant_index: u32,
232        _variant: &'static str,
233        _len: usize,
234    ) -> Result<Self::SerializeStructVariant, Self::Error> {
235        Err(Error::UnsupportedType(Some(name)))
236    }
237}
toml_edit/ser/value.rs

toml_edit/ser/
value.rs
