toml_datetime/
ser.rs

1//! Serialization support for [`Datetime`][crate::Datetime]
2
3/// Check if serializing a [`Datetime`][crate::Datetime]
4pub fn is_datetime(name: &'static str) -> bool {
5    crate::datetime::is_datetime(name)
6}
7
8/// See [`DatetimeSerializer`]
9#[derive(Debug)]
10#[non_exhaustive]
11pub enum SerializerError {
12    /// Unsupported datetime format
13    InvalidFormat(crate::DatetimeParseError),
14    /// Unsupported serialization protocol
15    InvalidProtocol,
16}
17
18impl serde::ser::Error for SerializerError {
19    fn custom<T>(_msg: T) -> Self
20    where
21        T: core::fmt::Display,
22    {
23        Self::InvalidProtocol
24    }
25}
26
27impl core::fmt::Display for SerializerError {
28    fn fmt(&self, formatter: &mut core::fmt::Formatter<'_>) -> core::fmt::Result {
29        match self {
30            Self::InvalidFormat(e) => e.fmt(formatter),
31            Self::InvalidProtocol => "invalid serialization protocol".fmt(formatter),
32        }
33    }
34}
35
36#[cfg(feature = "std")]
37impl std::error::Error for SerializerError {}
38#[cfg(all(not(feature = "std"), feature = "serde"))]
39impl serde::de::StdError for SerializerError {}
40
41/// Serializer / format support for emitting [`Datetime`][crate::Datetime]
42#[derive(Default)]
43pub struct DatetimeSerializer {
44    value: Option<crate::Datetime>,
45}
46
47impl DatetimeSerializer {
48    /// Create a serializer to emit [`Datetime`][crate::Datetime]
49    pub fn new() -> Self {
50        Self { value: None }
51    }
52
53    /// See [`serde::ser::SerializeStruct::serialize_field`]
54    pub fn serialize_field<T>(
55        &mut self,
56        key: &'static str,
57        value: &T,
58    ) -> Result<(), SerializerError>
59    where
60        T: serde::ser::Serialize + ?Sized,
61    {
62        if key == crate::datetime::FIELD {
63            self.value = Some(value.serialize(DatetimeFieldSerializer::default())?);
64        }
65
66        Ok(())
67    }
68
69    /// See [`serde::ser::SerializeStruct::end`]
70    pub fn end(self) -> Result<crate::Datetime, SerializerError> {
71        self.value.ok_or(SerializerError::InvalidProtocol)
72    }
73}
74
75#[derive(Default)]
76struct DatetimeFieldSerializer {}
77
78impl serde::ser::Serializer for DatetimeFieldSerializer {
79    type Ok = crate::Datetime;
80    type Error = SerializerError;
81    type SerializeSeq = serde::ser::Impossible<Self::Ok, Self::Error>;
82    type SerializeTuple = serde::ser::Impossible<Self::Ok, Self::Error>;
83    type SerializeTupleStruct = serde::ser::Impossible<Self::Ok, Self::Error>;
84    type SerializeTupleVariant = serde::ser::Impossible<Self::Ok, Self::Error>;
85    type SerializeMap = serde::ser::Impossible<Self::Ok, Self::Error>;
86    type SerializeStruct = serde::ser::Impossible<Self::Ok, Self::Error>;
87    type SerializeStructVariant = serde::ser::Impossible<Self::Ok, Self::Error>;
88
89    fn serialize_bool(self, _value: bool) -> Result<Self::Ok, Self::Error> {
90        Err(SerializerError::InvalidProtocol)
91    }
92
93    fn serialize_i8(self, _value: i8) -> Result<Self::Ok, Self::Error> {
94        Err(SerializerError::InvalidProtocol)
95    }
96
97    fn serialize_i16(self, _value: i16) -> Result<Self::Ok, Self::Error> {
98        Err(SerializerError::InvalidProtocol)
99    }
100
101    fn serialize_i32(self, _value: i32) -> Result<Self::Ok, Self::Error> {
102        Err(SerializerError::InvalidProtocol)
103    }
104
105    fn serialize_i64(self, _value: i64) -> Result<Self::Ok, Self::Error> {
106        Err(SerializerError::InvalidProtocol)
107    }
108
109    fn serialize_u8(self, _value: u8) -> Result<Self::Ok, Self::Error> {
110        Err(SerializerError::InvalidProtocol)
111    }
112
113    fn serialize_u16(self, _value: u16) -> Result<Self::Ok, Self::Error> {
114        Err(SerializerError::InvalidProtocol)
115    }
116
117    fn serialize_u32(self, _value: u32) -> Result<Self::Ok, Self::Error> {
118        Err(SerializerError::InvalidProtocol)
119    }
120
121    fn serialize_u64(self, _value: u64) -> Result<Self::Ok, Self::Error> {
122        Err(SerializerError::InvalidProtocol)
123    }
124
125    fn serialize_f32(self, _value: f32) -> Result<Self::Ok, Self::Error> {
126        Err(SerializerError::InvalidProtocol)
127    }
128
129    fn serialize_f64(self, _value: f64) -> Result<Self::Ok, Self::Error> {
130        Err(SerializerError::InvalidProtocol)
131    }
132
133    fn serialize_char(self, _value: char) -> Result<Self::Ok, Self::Error> {
134        Err(SerializerError::InvalidProtocol)
135    }
136
137    fn serialize_str(self, v: &str) -> Result<Self::Ok, Self::Error> {
138        v.parse::<crate::Datetime>()
139            .map_err(SerializerError::InvalidFormat)
140    }
141
142    fn serialize_bytes(self, _value: &[u8]) -> Result<Self::Ok, Self::Error> {
143        Err(SerializerError::InvalidProtocol)
144    }
145
146    fn serialize_none(self) -> Result<Self::Ok, Self::Error> {
147        Err(SerializerError::InvalidProtocol)
148    }
149
150    fn serialize_some<T>(self, _value: &T) -> Result<Self::Ok, Self::Error>
151    where
152        T: serde::ser::Serialize + ?Sized,
153    {
154        Err(SerializerError::InvalidProtocol)
155    }
156
157    fn serialize_unit(self) -> Result<Self::Ok, Self::Error> {
158        Err(SerializerError::InvalidProtocol)
159    }
160
161    fn serialize_unit_struct(self, _name: &'static str) -> Result<Self::Ok, Self::Error> {
162        Err(SerializerError::InvalidProtocol)
163    }
164
165    fn serialize_unit_variant(
166        self,
167        _name: &'static str,
168        _variant_index: u32,
169        _variant: &'static str,
170    ) -> Result<Self::Ok, Self::Error> {
171        Err(SerializerError::InvalidProtocol)
172    }
173
174    fn serialize_newtype_struct<T>(
175        self,
176        _name: &'static str,
177        _value: &T,
178    ) -> Result<Self::Ok, Self::Error>
179    where
180        T: serde::ser::Serialize + ?Sized,
181    {
182        Err(SerializerError::InvalidProtocol)
183    }
184
185    fn serialize_newtype_variant<T>(
186        self,
187        _name: &'static str,
188        _variant_index: u32,
189        _variant: &'static str,
190        _value: &T,
191    ) -> Result<Self::Ok, Self::Error>
192    where
193        T: serde::ser::Serialize + ?Sized,
194    {
195        Err(SerializerError::InvalidProtocol)
196    }
197
198    fn serialize_seq(self, _len: Option<usize>) -> Result<Self::SerializeSeq, Self::Error> {
199        Err(SerializerError::InvalidProtocol)
200    }
201
202    fn serialize_tuple(self, _len: usize) -> Result<Self::SerializeTuple, Self::Error> {
203        Err(SerializerError::InvalidProtocol)
204    }
205
206    fn serialize_tuple_struct(
207        self,
208        _name: &'static str,
209        _len: usize,
210    ) -> Result<Self::SerializeTupleStruct, Self::Error> {
211        Err(SerializerError::InvalidProtocol)
212    }
213
214    fn serialize_tuple_variant(
215        self,
216        _name: &'static str,
217        _variant_index: u32,
218        _variant: &'static str,
219        _len: usize,
220    ) -> Result<Self::SerializeTupleVariant, Self::Error> {
221        Err(SerializerError::InvalidProtocol)
222    }
223
224    fn serialize_map(self, _len: Option<usize>) -> Result<Self::SerializeMap, Self::Error> {
225        Err(SerializerError::InvalidProtocol)
226    }
227
228    fn serialize_struct(
229        self,
230        _name: &'static str,
231        _len: usize,
232    ) -> Result<Self::SerializeStruct, Self::Error> {
233        Err(SerializerError::InvalidProtocol)
234    }
235
236    fn serialize_struct_variant(
237        self,
238        _name: &'static str,
239        _variant_index: u32,
240        _variant: &'static str,
241        _len: usize,
242    ) -> Result<Self::SerializeStructVariant, Self::Error> {
243        Err(SerializerError::InvalidProtocol)
244    }
245}
toml_datetime/ser.rs

toml_datetime/
ser.rs
