1use crate::Value;
2use crate::value::ValueInner;
3use crate::value::utils::DeserializationFailed;
4use serde::de::{self, Unexpected, Visitor};
5use serde::{Deserializer, forward_to_deserialize_any};
6
7#[derive(Debug)]
8pub struct ValueDeserializer {
9 value: Value,
10}
11
12impl ValueDeserializer {
13 pub fn from_value(value: Value) -> Self {
14 Self { value }
15 }
16}
17
18impl<'de> de::Deserializer<'de> for ValueDeserializer {
19 type Error = DeserializationFailed;
20
21 fn deserialize_any<V>(self, visitor: V) -> Result<V::Value, Self::Error>
22 where
23 V: Visitor<'de>,
24 {
25 match self.value.inner {
26 ValueInner::Bool(v) => visitor.visit_bool(v),
27 ValueInner::I64(v) => visitor.visit_i64(v),
28 ValueInner::U64(v) => visitor.visit_u64(v),
29 ValueInner::I128(v) => visitor.visit_i128(*v),
30 ValueInner::U128(v) => visitor.visit_u128(*v),
31 ValueInner::F64(v) => visitor.visit_f64(v),
32 ValueInner::String(v) => visitor.visit_str(v.as_str()),
33 ValueInner::Bytes(v) => visitor.visit_bytes(&v),
34 ValueInner::Undefined | ValueInner::None => visitor.visit_unit(),
35 ValueInner::Array(v) => visitor.visit_seq(de::value::SeqDeserializer::new(
36 v.iter().map(|v| ValueDeserializer::from_value(v.clone())),
37 )),
38 ValueInner::Map(v) => {
39 visitor.visit_map(de::value::MapDeserializer::new(v.iter().map(|(k, v)| {
40 (
41 ValueDeserializer::from_value(k.as_value()),
42 ValueDeserializer::from_value(v.clone()),
43 )
44 })))
45 }
46 }
47 }
48
49 fn deserialize_option<V>(self, visitor: V) -> Result<V::Value, Self::Error>
50 where
51 V: Visitor<'de>,
52 {
53 match self.value.inner {
54 ValueInner::Undefined | ValueInner::None => visitor.visit_unit(),
55 _ => visitor.visit_some(self),
56 }
57 }
58
59 fn deserialize_enum<V>(
60 self,
61 _name: &'static str,
62 _variants: &'static [&'static str],
63 visitor: V,
64 ) -> Result<V::Value, Self::Error>
65 where
66 V: Visitor<'de>,
67 {
68 let (variant, params) = match self.value.inner {
69 ValueInner::Map(m) => {
70 let mut iter = m.iter();
71 let (variant, value) = match iter.next() {
72 Some(v) => v,
73 None => {
74 return Err(de::Error::invalid_value(
75 Unexpected::Map,
76 &"map with a single key",
77 ));
78 }
79 };
80 if iter.next().is_some() {
82 return Err(de::Error::invalid_value(
83 Unexpected::Map,
84 &"map with a single key",
85 ));
86 }
87 (variant.as_value(), Some(value.clone()))
88 }
89 ValueInner::String(_) => (self.value.clone(), None),
90 _ => {
91 return Err(de::Error::invalid_type(
92 Unexpected::Other(self.value.name()),
93 &"map or string",
94 ));
95 }
96 };
97 visitor.visit_enum(EnumDeserializer { variant, params })
98 }
99
100 fn deserialize_newtype_struct<V>(
101 self,
102 _name: &'static str,
103 visitor: V,
104 ) -> Result<V::Value, Self::Error>
105 where
106 V: Visitor<'de>,
107 {
108 visitor.visit_newtype_struct(self)
109 }
110
111 forward_to_deserialize_any! {
112 bool u8 u16 u32 u64 i8 i16 i32 i64 i128 u128 f32 f64 char str string unit
113 seq bytes byte_buf map unit_struct
114 tuple_struct struct tuple ignored_any identifier
115 }
116}
117
118struct EnumDeserializer {
119 variant: Value,
120 params: Option<Value>,
121}
122
123impl<'de> de::EnumAccess<'de> for EnumDeserializer {
124 type Error = DeserializationFailed;
125 type Variant = VariantDeserializer;
126
127 fn variant_seed<V: de::DeserializeSeed<'de>>(
128 self,
129 seed: V,
130 ) -> Result<(V::Value, Self::Variant), Self::Error> {
131 let value = seed.deserialize(self.variant)?;
132 Ok((
133 value,
134 VariantDeserializer {
135 params: self.params,
136 },
137 ))
138 }
139}
140
141struct VariantDeserializer {
142 params: Option<Value>,
143}
144impl<'de> de::VariantAccess<'de> for VariantDeserializer {
145 type Error = DeserializationFailed;
146
147 fn unit_variant(self) -> Result<(), Self::Error> {
148 match self.params {
149 Some(value) => de::Deserialize::deserialize(value),
150 None => Ok(()),
151 }
152 }
153
154 fn newtype_variant_seed<T: de::DeserializeSeed<'de>>(
155 self,
156 seed: T,
157 ) -> Result<T::Value, Self::Error> {
158 match self.params {
159 Some(value) => seed.deserialize(value),
160 None => Err(de::Error::invalid_type(
161 Unexpected::UnitVariant,
162 &"newtype variant",
163 )),
164 }
165 }
166
167 fn tuple_variant<V: Visitor<'de>>(
168 self,
169 _len: usize,
170 visitor: V,
171 ) -> Result<V::Value, Self::Error> {
172 match self.params.filter(|x| x.is_array()) {
173 Some(val) => ValueDeserializer::from_value(val).deserialize_any(visitor),
174 _ => Err(de::Error::invalid_type(
175 Unexpected::UnitVariant,
176 &"tuple variant",
177 )),
178 }
179 }
180
181 fn struct_variant<V: Visitor<'de>>(
182 self,
183 _fields: &'static [&'static str],
184 visitor: V,
185 ) -> Result<V::Value, Self::Error> {
186 match self.params.filter(|x| x.is_map()) {
187 Some(val) => ValueDeserializer::from_value(val).deserialize_any(visitor),
188 _ => Err(de::Error::invalid_type(
189 Unexpected::UnitVariant,
190 &"struct variant",
191 )),
192 }
193 }
194}
195
196impl<'de> de::IntoDeserializer<'de, DeserializationFailed> for ValueDeserializer {
197 type Deserializer = ValueDeserializer;
198
199 fn into_deserializer(self) -> ValueDeserializer {
200 self
201 }
202}
203
204impl<'de> de::Deserializer<'de> for Value {
205 type Error = DeserializationFailed;
206
207 fn deserialize_any<V: de::Visitor<'de>>(self, visitor: V) -> Result<V::Value, Self::Error> {
208 ValueDeserializer::from_value(self).deserialize_any(visitor)
209 }
210
211 fn deserialize_option<V: de::Visitor<'de>>(self, visitor: V) -> Result<V::Value, Self::Error> {
212 ValueDeserializer::from_value(self).deserialize_option(visitor)
213 }
214
215 fn deserialize_newtype_struct<V: de::Visitor<'de>>(
216 self,
217 name: &'static str,
218 visitor: V,
219 ) -> Result<V::Value, Self::Error> {
220 ValueDeserializer::from_value(self).deserialize_newtype_struct(name, visitor)
221 }
222
223 fn deserialize_enum<V: de::Visitor<'de>>(
224 self,
225 name: &'static str,
226 variants: &'static [&'static str],
227 visitor: V,
228 ) -> Result<V::Value, Self::Error> {
229 ValueDeserializer::from_value(self).deserialize_enum(name, variants, visitor)
230 }
231
232 forward_to_deserialize_any! {
233 bool u8 u16 u32 u64 i8 i16 i32 i64 i128 u128 f32 f64 char str string unit
234 seq bytes byte_buf map unit_struct
235 tuple_struct struct tuple ignored_any identifier
236 }
237}
238
239impl<'de> de::Deserializer<'de> for &Value {
240 type Error = DeserializationFailed;
241
242 fn deserialize_any<V: de::Visitor<'de>>(self, visitor: V) -> Result<V::Value, Self::Error> {
243 ValueDeserializer::from_value(self.clone()).deserialize_any(visitor)
244 }
245
246 fn deserialize_option<V: de::Visitor<'de>>(self, visitor: V) -> Result<V::Value, Self::Error> {
247 ValueDeserializer::from_value(self.clone()).deserialize_option(visitor)
248 }
249
250 fn deserialize_newtype_struct<V: de::Visitor<'de>>(
251 self,
252 name: &'static str,
253 visitor: V,
254 ) -> Result<V::Value, Self::Error> {
255 ValueDeserializer::from_value(self.clone()).deserialize_newtype_struct(name, visitor)
256 }
257
258 fn deserialize_enum<V: de::Visitor<'de>>(
259 self,
260 name: &'static str,
261 variants: &'static [&'static str],
262 visitor: V,
263 ) -> Result<V::Value, Self::Error> {
264 ValueDeserializer::from_value(self.clone()).deserialize_enum(name, variants, visitor)
265 }
266
267 forward_to_deserialize_any! {
268 bool u8 u16 u32 u64 i8 i16 i32 i64 i128 u128 f32 f64 char str string unit
269 seq bytes byte_buf map unit_struct
270 tuple_struct struct tuple ignored_any identifier
271 }
272}
273
274#[cfg(test)]
275mod tests {
276 use super::*;
277 use serde::Deserialize;
278 use serde::Serialize;
279
280 #[derive(Debug, Serialize, Deserialize, PartialEq)]
281 struct UserId(u64);
282
283 #[derive(Debug, Serialize, Deserialize, PartialEq)]
284 enum Kind {
285 Article,
286 Comment(String),
287 Tuple(usize, usize),
288 Other { truthy: bool },
289 }
290
291 #[derive(Debug, Serialize, Deserialize, PartialEq)]
292 struct Content {
293 text: String,
294 num_likes: u64,
295 published: bool,
296 kind: Kind,
297 kind2: Kind,
298 kind3: Kind,
299 kind4: Kind,
300 maybe: Option<u64>,
301 nothing: Option<u64>,
302 user_id: UserId,
303 }
304
305 #[test]
306 fn test_deser() {
307 let instance = Content {
308 text: "hello".to_string(),
309 num_likes: 10,
310 published: true,
311 kind: Kind::Article,
312 kind2: Kind::Comment(String::new()),
313 kind3: Kind::Tuple(1, 1),
314 kind4: Kind::Other { truthy: true },
315 maybe: Some(42),
316 nothing: None,
317 user_id: UserId(1),
318 };
319 let val = Value::from_serializable(&instance);
320 let out = Content::deserialize(&val).unwrap();
321 assert_eq!(out, instance);
322 let out = Content::deserialize(val).unwrap();
323 assert_eq!(out, instance);
324 }
325}