1use alloc::string::ToString;
4
5use serde_core::de::IntoDeserializer;
6use serde_core::de::value::BorrowedStrDeserializer;
7
8pub fn is_datetime(name: &'static str) -> bool {
10 crate::datetime::is_datetime(name)
11}
12
13pub struct DatetimeDeserializer<E> {
15 date: Option<crate::Datetime>,
16 _error: core::marker::PhantomData<E>,
17}
18
19impl<E> DatetimeDeserializer<E> {
20 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#[cfg(feature = "alloc")]
65pub enum VisitMap<'de> {
66 Datetime(crate::Datetime),
68 Key(alloc::borrow::Cow<'de, str>),
70}
71
72impl<'de> VisitMap<'de> {
73 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}