Skip to main content

toml_datetime/
de.rs

1//! Deserialization support for [`Datetime`][crate::Datetime]
2
3use alloc::string::ToString;
4
5use serde_core::de::IntoDeserializer;
6use serde_core::de::value::BorrowedStrDeserializer;
7
8/// Check if deserializing a [`Datetime`][crate::Datetime]
9pub fn is_datetime(name: &'static str) -> bool {
10    crate::datetime::is_datetime(name)
11}
12
13/// Deserializer / format support for emitting [`Datetime`][crate::Datetime]
14pub struct DatetimeDeserializer<E> {
15    date: Option<crate::Datetime>,
16    _error: core::marker::PhantomData<E>,
17}
18
19impl<E> DatetimeDeserializer<E> {
20    /// Create a deserializer to emit [`Datetime`][crate::Datetime]
21    pub fn new(date: crate::Datetime) -> Self {
22        Self {
23            date: Some(date),
24            _error: Default::default(),
25        }
26    }
27}
28
29impl<'de, E> serde_core::de::MapAccess<'de> for DatetimeDeserializer<E>
30where
31    E: serde_core::de::Error,
32{
33    type Error = E;
34
35    fn next_key_seed<K>(&mut self, seed: K) -> Result<Option<K::Value>, Self::Error>
36    where
37        K: serde_core::de::DeserializeSeed<'de>,
38    {
39        if self.date.is_some() {
40            seed.deserialize(BorrowedStrDeserializer::new(crate::datetime::FIELD))
41                .map(Some)
42        } else {
43            Ok(None)
44        }
45    }
46
47    fn next_value_seed<V>(&mut self, seed: V) -> Result<V::Value, Self::Error>
48    where
49        V: serde_core::de::DeserializeSeed<'de>,
50    {
51        if let Some(date) = self.date.take() {
52            seed.deserialize(date.to_string().into_deserializer())
53        } else {
54            panic!("next_value_seed called before next_key_seed")
55        }
56    }
57
58    fn size_hint(&self) -> Option<usize> {
59        Some(usize::from(self.date.is_some()))
60    }
61}
62
63/// Integrate [`Datetime`][crate::Datetime] into an untagged deserialize
64#[cfg(feature = "alloc")]
65pub enum VisitMap<'de> {
66    /// The map was deserialized as a [Datetime][crate::Datetime] value
67    Datetime(crate::Datetime),
68    /// The map is of an unknown format and needs further deserialization
69    Key(alloc::borrow::Cow<'de, str>),
70}
71
72impl<'de> VisitMap<'de> {
73    /// Determine the type of the map by deserializing it
74    pub fn next_key_seed<V: serde_core::de::MapAccess<'de>>(
75        visitor: &mut V,
76    ) -> Result<Option<Self>, V::Error> {
77        let mut key = None;
78        let Some(()) = visitor.next_key_seed(DatetimeOrTable::new(&mut key))? else {
79            return Ok(None);
80        };
81        let result = if let Some(key) = key {
82            VisitMap::Key(key)
83        } else {
84            let date: crate::datetime::DatetimeFromString = visitor.next_value()?;
85            VisitMap::Datetime(date.value)
86        };
87        Ok(Some(result))
88    }
89}
90
91struct DatetimeOrTable<'m, 'de> {
92    key: &'m mut Option<alloc::borrow::Cow<'de, str>>,
93}
94
95impl<'m, 'de> DatetimeOrTable<'m, 'de> {
96    fn new(key: &'m mut Option<alloc::borrow::Cow<'de, str>>) -> Self {
97        *key = None;
98        Self { key }
99    }
100}
101
102impl<'de> serde_core::de::DeserializeSeed<'de> for DatetimeOrTable<'_, 'de> {
103    type Value = ();
104
105    fn deserialize<D>(self, deserializer: D) -> Result<Self::Value, D::Error>
106    where
107        D: serde_core::de::Deserializer<'de>,
108    {
109        deserializer.deserialize_any(self)
110    }
111}
112
113impl<'de> serde_core::de::Visitor<'de> for DatetimeOrTable<'_, 'de> {
114    type Value = ();
115
116    fn expecting(&self, formatter: &mut core::fmt::Formatter<'_>) -> core::fmt::Result {
117        formatter.write_str("a string key")
118    }
119
120    fn visit_str<E>(self, s: &str) -> Result<Self::Value, E>
121    where
122        E: serde_core::de::Error,
123    {
124        if s == crate::datetime::FIELD {
125            *self.key = None;
126            Ok(())
127        } else {
128            use crate::alloc::borrow::ToOwned as _;
129            *self.key = Some(alloc::borrow::Cow::Owned(s.to_owned()));
130            Ok(())
131        }
132    }
133
134    fn visit_borrowed_str<E>(self, s: &'de str) -> Result<Self::Value, E>
135    where
136        E: serde_core::de::Error,
137    {
138        if s == crate::datetime::FIELD {
139            *self.key = None;
140            Ok(())
141        } else {
142            *self.key = Some(alloc::borrow::Cow::Borrowed(s));
143            Ok(())
144        }
145    }
146
147    #[allow(unused_qualifications)]
148    fn visit_string<E>(self, s: alloc::string::String) -> Result<Self::Value, E>
149    where
150        E: serde_core::de::Error,
151    {
152        if s == crate::datetime::FIELD {
153            *self.key = None;
154            Ok(())
155        } else {
156            *self.key = Some(alloc::borrow::Cow::Owned(s));
157            Ok(())
158        }
159    }
160}