toml/ser/document/
strategy.rs

1#[derive(Copy, Clone, PartialEq, Eq, Debug)]
2pub(crate) enum SerializationStrategy {
3    Value,
4    Table,
5    ArrayOfTables,
6    Skip,
7    Unknown,
8}
9
10impl<T> From<&T> for SerializationStrategy
11where
12    T: serde::ser::Serialize + ?Sized,
13{
14    fn from(value: &T) -> Self {
15        value.serialize(WalkValue).unwrap_err()
16    }
17}
18
19impl serde::ser::Error for SerializationStrategy {
20    fn custom<T>(_msg: T) -> Self
21    where
22        T: core::fmt::Display,
23    {
24        Self::Unknown
25    }
26}
27
28impl core::fmt::Display for SerializationStrategy {
29    fn fmt(&self, f: &mut core::fmt::Formatter<'_>) -> core::fmt::Result {
30        "error".fmt(f)
31    }
32}
33
34#[cfg(feature = "std")]
35impl std::error::Error for SerializationStrategy {}
36#[cfg(not(feature = "std"))]
37impl serde::de::StdError for SerializationStrategy {}
38
39struct WalkValue;
40
41impl serde::ser::Serializer for WalkValue {
42    type Ok = core::convert::Infallible;
43    type Error = SerializationStrategy;
44    type SerializeSeq = ArrayWalkValue;
45    type SerializeTuple = ArrayWalkValue;
46    type SerializeTupleStruct = ArrayWalkValue;
47    type SerializeTupleVariant = serde::ser::Impossible<Self::Ok, Self::Error>;
48    type SerializeMap = serde::ser::Impossible<Self::Ok, Self::Error>;
49    type SerializeStruct = StructWalkValue;
50    type SerializeStructVariant = serde::ser::Impossible<Self::Ok, Self::Error>;
51
52    fn serialize_bool(self, _v: bool) -> Result<Self::Ok, Self::Error> {
53        Err(SerializationStrategy::Value)
54    }
55
56    fn serialize_i8(self, _v: i8) -> Result<Self::Ok, Self::Error> {
57        Err(SerializationStrategy::Value)
58    }
59
60    fn serialize_i16(self, _v: i16) -> Result<Self::Ok, Self::Error> {
61        Err(SerializationStrategy::Value)
62    }
63
64    fn serialize_i32(self, _v: i32) -> Result<Self::Ok, Self::Error> {
65        Err(SerializationStrategy::Value)
66    }
67
68    fn serialize_i64(self, _v: i64) -> Result<Self::Ok, Self::Error> {
69        Err(SerializationStrategy::Value)
70    }
71
72    fn serialize_i128(self, _v: i128) -> Result<Self::Ok, Self::Error> {
73        Err(SerializationStrategy::Value)
74    }
75
76    fn serialize_u8(self, _v: u8) -> Result<Self::Ok, Self::Error> {
77        Err(SerializationStrategy::Value)
78    }
79
80    fn serialize_u16(self, _v: u16) -> Result<Self::Ok, Self::Error> {
81        Err(SerializationStrategy::Value)
82    }
83
84    fn serialize_u32(self, _v: u32) -> Result<Self::Ok, Self::Error> {
85        Err(SerializationStrategy::Value)
86    }
87
88    fn serialize_u64(self, _v: u64) -> Result<Self::Ok, Self::Error> {
89        Err(SerializationStrategy::Value)
90    }
91
92    fn serialize_u128(self, _v: u128) -> Result<Self::Ok, Self::Error> {
93        Err(SerializationStrategy::Value)
94    }
95
96    fn serialize_f32(self, _v: f32) -> Result<Self::Ok, Self::Error> {
97        Err(SerializationStrategy::Value)
98    }
99
100    fn serialize_f64(self, _v: f64) -> Result<Self::Ok, Self::Error> {
101        Err(SerializationStrategy::Value)
102    }
103
104    fn serialize_char(self, _v: char) -> Result<Self::Ok, Self::Error> {
105        Err(SerializationStrategy::Value)
106    }
107
108    fn serialize_str(self, _v: &str) -> Result<Self::Ok, Self::Error> {
109        Err(SerializationStrategy::Value)
110    }
111
112    fn serialize_bytes(self, _v: &[u8]) -> Result<Self::Ok, Self::Error> {
113        Err(SerializationStrategy::Value)
114    }
115
116    fn serialize_none(self) -> Result<Self::Ok, Self::Error> {
117        Err(SerializationStrategy::Skip)
118    }
119
120    fn serialize_some<T>(self, v: &T) -> Result<Self::Ok, Self::Error>
121    where
122        T: serde::ser::Serialize + ?Sized,
123    {
124        v.serialize(self)
125    }
126
127    fn serialize_unit(self) -> Result<Self::Ok, Self::Error> {
128        Err(SerializationStrategy::Value)
129    }
130
131    fn serialize_unit_struct(self, _name: &'static str) -> Result<Self::Ok, Self::Error> {
132        Err(SerializationStrategy::Value)
133    }
134
135    fn serialize_unit_variant(
136        self,
137        _name: &'static str,
138        _variant_index: u32,
139        _variant: &'static str,
140    ) -> Result<Self::Ok, Self::Error> {
141        Err(SerializationStrategy::Value)
142    }
143
144    fn serialize_newtype_struct<T>(
145        self,
146        _name: &'static str,
147        v: &T,
148    ) -> Result<Self::Ok, Self::Error>
149    where
150        T: serde::ser::Serialize + ?Sized,
151    {
152        v.serialize(self)
153    }
154
155    fn serialize_newtype_variant<T>(
156        self,
157        _name: &'static str,
158        _variant_index: u32,
159        _variant: &'static str,
160        _value: &T,
161    ) -> Result<Self::Ok, Self::Error>
162    where
163        T: serde::ser::Serialize + ?Sized,
164    {
165        Err(SerializationStrategy::Table)
166    }
167
168    fn serialize_seq(self, _len: Option<usize>) -> Result<Self::SerializeSeq, Self::Error> {
169        Ok(ArrayWalkValue::new())
170    }
171
172    fn serialize_tuple(self, len: usize) -> Result<Self::SerializeTuple, Self::Error> {
173        self.serialize_seq(Some(len))
174    }
175
176    fn serialize_tuple_struct(
177        self,
178        _name: &'static str,
179        len: usize,
180    ) -> Result<Self::SerializeTupleStruct, Self::Error> {
181        self.serialize_seq(Some(len))
182    }
183
184    fn serialize_tuple_variant(
185        self,
186        _name: &'static str,
187        _variant_index: u32,
188        _variant: &'static str,
189        _len: usize,
190    ) -> Result<Self::SerializeTupleVariant, Self::Error> {
191        Err(SerializationStrategy::Table)
192    }
193
194    fn serialize_map(self, _len: Option<usize>) -> Result<Self::SerializeMap, Self::Error> {
195        Err(SerializationStrategy::Table)
196    }
197
198    fn serialize_struct(
199        self,
200        name: &'static str,
201        _len: usize,
202    ) -> Result<Self::SerializeStruct, Self::Error> {
203        if toml_datetime::ser::is_datetime(name) {
204            Ok(StructWalkValue)
205        } else {
206            Err(SerializationStrategy::Table)
207        }
208    }
209
210    fn serialize_struct_variant(
211        self,
212        _name: &'static str,
213        _variant_index: u32,
214        _variant: &'static str,
215        _len: usize,
216    ) -> Result<Self::SerializeStructVariant, Self::Error> {
217        Err(SerializationStrategy::Table)
218    }
219}
220
221#[doc(hidden)]
222pub(crate) struct ArrayWalkValue {
223    is_empty: bool,
224}
225
226impl ArrayWalkValue {
227    fn new() -> Self {
228        Self { is_empty: true }
229    }
230
231    fn serialize_element<T>(&mut self, value: &T) -> Result<(), SerializationStrategy>
232    where
233        T: serde::ser::Serialize + ?Sized,
234    {
235        self.is_empty = false;
236        match SerializationStrategy::from(value) {
237            SerializationStrategy::Value
238            | SerializationStrategy::ArrayOfTables
239            | SerializationStrategy::Unknown
240            | SerializationStrategy::Skip => Err(SerializationStrategy::Value),
241            SerializationStrategy::Table => Ok(()),
242        }
243    }
244
245    fn end(self) -> Result<core::convert::Infallible, SerializationStrategy> {
246        if self.is_empty {
247            Err(SerializationStrategy::Value)
248        } else {
249            Err(SerializationStrategy::ArrayOfTables)
250        }
251    }
252}
253
254impl serde::ser::SerializeSeq for ArrayWalkValue {
255    type Ok = core::convert::Infallible;
256    type Error = SerializationStrategy;
257
258    fn serialize_element<T>(&mut self, value: &T) -> Result<(), Self::Error>
259    where
260        T: serde::ser::Serialize + ?Sized,
261    {
262        self.serialize_element(value)
263    }
264
265    fn end(self) -> Result<Self::Ok, Self::Error> {
266        self.end()
267    }
268}
269
270impl serde::ser::SerializeTuple for ArrayWalkValue {
271    type Ok = core::convert::Infallible;
272    type Error = SerializationStrategy;
273
274    fn serialize_element<T>(&mut self, value: &T) -> Result<(), Self::Error>
275    where
276        T: serde::ser::Serialize + ?Sized,
277    {
278        self.serialize_element(value)
279    }
280
281    fn end(self) -> Result<Self::Ok, Self::Error> {
282        self.end()
283    }
284}
285
286impl serde::ser::SerializeTupleStruct for ArrayWalkValue {
287    type Ok = core::convert::Infallible;
288    type Error = SerializationStrategy;
289
290    fn serialize_field<T>(&mut self, value: &T) -> Result<(), Self::Error>
291    where
292        T: serde::ser::Serialize + ?Sized,
293    {
294        self.serialize_element(value)
295    }
296
297    fn end(self) -> Result<Self::Ok, Self::Error> {
298        self.end()
299    }
300}
301
302pub(crate) struct StructWalkValue;
303
304impl serde::ser::SerializeMap for StructWalkValue {
305    type Ok = core::convert::Infallible;
306    type Error = SerializationStrategy;
307
308    fn serialize_key<T>(&mut self, _input: &T) -> Result<(), Self::Error>
309    where
310        T: serde::ser::Serialize + ?Sized,
311    {
312        Ok(())
313    }
314
315    fn serialize_value<T>(&mut self, _value: &T) -> Result<(), Self::Error>
316    where
317        T: serde::ser::Serialize + ?Sized,
318    {
319        Ok(())
320    }
321
322    fn end(self) -> Result<Self::Ok, Self::Error> {
323        // is date time
324        Err(SerializationStrategy::Value)
325    }
326}
327
328impl serde::ser::SerializeStruct for StructWalkValue {
329    type Ok = core::convert::Infallible;
330    type Error = SerializationStrategy;
331
332    fn serialize_field<T>(&mut self, _key: &'static str, _value: &T) -> Result<(), Self::Error>
333    where
334        T: serde::ser::Serialize + ?Sized,
335    {
336        Ok(())
337    }
338
339    fn end(self) -> Result<Self::Ok, Self::Error> {
340        // is date time
341        Err(SerializationStrategy::Value)
342    }
343}
toml/ser/document/strategy.rs

toml/ser/document/
strategy.rs
