serde_firestore_value/de/
firestore_value_deserializer.rs

1use crate::google::firestore::v1::{value::ValueType, Value};
2use crate::{error::ErrorCode, value_ext::ValueExt, Error, LatLng, Reference, Timestamp};
3
4use super::{
5    firestore_array_value_deserializer::FirestoreArrayValueDeserializer,
6    firestore_enum_deserializer::FirestoreEnumDeserializer,
7    firestore_geo_point_value_deserializer::FirestoreGeoPointValueDeserializer,
8    firestore_map_value_deserializer::FirestoreMapValueDeserializer,
9    firestore_reference_value_deserializer::FirestoreReferenceValueDeserializer,
10    firestore_struct_map_value_deserializer::FirestoreStructMapValueDeserializer,
11    firestore_timestamp_value_deserializer::FirestoreTimestampValueDeserializer,
12};
13
14/// A Deserializer type which implements [`serde::Deserializer`] for [`Value`].
15#[derive(Debug)]
16pub struct FirestoreValueDeserializer<'a> {
17    value: &'a Value,
18}
19
20impl<'de> FirestoreValueDeserializer<'de> {
21    /// Creates a new [`FirestoreValueDeserializer`].
22    pub fn new(value: &'de Value) -> Self {
23        Self { value }
24    }
25}
26
27impl<'a> serde::Deserializer<'a> for FirestoreValueDeserializer<'a> {
28    type Error = Error;
29
30    fn deserialize_any<V>(self, visitor: V) -> Result<V::Value, Self::Error>
31    where
32        V: serde::de::Visitor<'a>,
33    {
34        match self.value.value_type {
35            Some(ref value_type) => match value_type {
36                ValueType::NullValue(_) => visitor.visit_unit(),
37                ValueType::BooleanValue(v) => visitor.visit_bool(*v),
38                ValueType::IntegerValue(v) => visitor.visit_i64(*v),
39                ValueType::DoubleValue(v) => visitor.visit_f64(*v),
40                ValueType::TimestampValue(_) => {
41                    visitor.visit_map(FirestoreTimestampValueDeserializer::new(self.value)?)
42                }
43                ValueType::StringValue(v) => visitor.visit_str(v),
44                ValueType::BytesValue(v) => visitor.visit_bytes(v),
45                ValueType::ReferenceValue(v) => visitor.visit_str(v),
46                ValueType::GeoPointValue(_) => {
47                    visitor.visit_map(FirestoreGeoPointValueDeserializer::new(self.value)?)
48                }
49                ValueType::ArrayValue(_) => {
50                    visitor.visit_seq(FirestoreArrayValueDeserializer::new(self.value)?)
51                }
52                ValueType::MapValue(_) => {
53                    visitor.visit_map(FirestoreMapValueDeserializer::new(self.value)?)
54                }
55            },
56            None => Err(Error::from(ErrorCode::ValueTypeMustBeSome)),
57        }
58    }
59
60    fn deserialize_bool<V>(self, visitor: V) -> Result<V::Value, Self::Error>
61    where
62        V: serde::de::Visitor<'a>,
63    {
64        let value = self.value.as_boolean()?;
65        visitor.visit_bool(value)
66    }
67
68    fn deserialize_i8<V>(self, visitor: V) -> Result<V::Value, Self::Error>
69    where
70        V: serde::de::Visitor<'a>,
71    {
72        let value = self.value.as_integer()?;
73        visitor.visit_i8(i8::try_from(value).map_err(|_| Error::from(ErrorCode::I8OutOfRange))?)
74    }
75
76    fn deserialize_i16<V>(self, visitor: V) -> Result<V::Value, Self::Error>
77    where
78        V: serde::de::Visitor<'a>,
79    {
80        let value = self.value.as_integer()?;
81        visitor.visit_i16(i16::try_from(value).map_err(|_| Error::from(ErrorCode::I16OutOfRange))?)
82    }
83
84    fn deserialize_i32<V>(self, visitor: V) -> Result<V::Value, Self::Error>
85    where
86        V: serde::de::Visitor<'a>,
87    {
88        let value = self.value.as_integer()?;
89        visitor.visit_i32(i32::try_from(value).map_err(|_| Error::from(ErrorCode::I32OutOfRange))?)
90    }
91
92    fn deserialize_i64<V>(self, visitor: V) -> Result<V::Value, Self::Error>
93    where
94        V: serde::de::Visitor<'a>,
95    {
96        let value = self.value.as_integer()?;
97        visitor.visit_i64(value)
98    }
99
100    fn deserialize_u8<V>(self, visitor: V) -> Result<V::Value, Self::Error>
101    where
102        V: serde::de::Visitor<'a>,
103    {
104        let value = self.value.as_integer()?;
105        visitor.visit_u8(u8::try_from(value).map_err(|_| Error::from(ErrorCode::U8OutOfRange))?)
106    }
107
108    fn deserialize_u16<V>(self, visitor: V) -> Result<V::Value, Self::Error>
109    where
110        V: serde::de::Visitor<'a>,
111    {
112        let value = self.value.as_integer()?;
113        visitor.visit_u16(u16::try_from(value).map_err(|_| Error::from(ErrorCode::U16OutOfRange))?)
114    }
115
116    fn deserialize_u32<V>(self, visitor: V) -> Result<V::Value, Self::Error>
117    where
118        V: serde::de::Visitor<'a>,
119    {
120        let value = self.value.as_integer()?;
121        visitor.visit_u32(u32::try_from(value).map_err(|_| Error::from(ErrorCode::U32OutOfRange))?)
122    }
123
124    fn deserialize_u64<V>(self, _: V) -> Result<V::Value, Self::Error>
125    where
126        V: serde::de::Visitor<'a>,
127    {
128        Err(Error::from(ErrorCode::U64IsNotSupported))
129    }
130
131    fn deserialize_f32<V>(self, visitor: V) -> Result<V::Value, Self::Error>
132    where
133        V: serde::de::Visitor<'a>,
134    {
135        let value = self.value.as_double()?;
136        visitor.visit_f32(value as f32)
137    }
138
139    fn deserialize_f64<V>(self, visitor: V) -> Result<V::Value, Self::Error>
140    where
141        V: serde::de::Visitor<'a>,
142    {
143        let value = self.value.as_double()?;
144        visitor.visit_f64(value)
145    }
146
147    fn deserialize_char<V>(self, visitor: V) -> Result<V::Value, Self::Error>
148    where
149        V: serde::de::Visitor<'a>,
150    {
151        let value = self.value.as_string()?;
152        let mut chars = value.chars();
153        match (chars.next(), chars.next()) {
154            (None, None) => Err(Error::from(ErrorCode::StringIsEmpty)),
155            (None, Some(_)) => unreachable!(),
156            (Some(c), None) => visitor.visit_char(c),
157            (Some(_), Some(_)) => Err(Error::from(ErrorCode::TooManyChars)),
158        }
159    }
160
161    fn deserialize_str<V>(self, visitor: V) -> Result<V::Value, Self::Error>
162    where
163        V: serde::de::Visitor<'a>,
164    {
165        let value = self.value.as_string()?;
166        visitor.visit_str(value)
167    }
168
169    fn deserialize_string<V>(self, visitor: V) -> Result<V::Value, Self::Error>
170    where
171        V: serde::de::Visitor<'a>,
172    {
173        self.deserialize_str(visitor)
174    }
175
176    fn deserialize_bytes<V>(self, visitor: V) -> Result<V::Value, Self::Error>
177    where
178        V: serde::de::Visitor<'a>,
179    {
180        let value = self.value.as_bytes()?;
181        visitor.visit_bytes(value)
182    }
183
184    fn deserialize_byte_buf<V>(self, visitor: V) -> Result<V::Value, Self::Error>
185    where
186        V: serde::de::Visitor<'a>,
187    {
188        let value = self.value.as_bytes()?;
189        visitor.visit_byte_buf(value.to_vec())
190    }
191
192    fn deserialize_option<V>(self, visitor: V) -> Result<V::Value, Self::Error>
193    where
194        V: serde::de::Visitor<'a>,
195    {
196        match self.value.value_type()? {
197            ValueType::NullValue(_) => visitor.visit_none(),
198            _ => visitor.visit_some(self),
199        }
200    }
201
202    fn deserialize_unit<V>(self, visitor: V) -> Result<V::Value, Self::Error>
203    where
204        V: serde::de::Visitor<'a>,
205    {
206        self.value.as_null()?;
207        visitor.visit_unit()
208    }
209
210    fn deserialize_unit_struct<V>(
211        self,
212        _name: &'static str,
213        visitor: V,
214    ) -> Result<V::Value, Self::Error>
215    where
216        V: serde::de::Visitor<'a>,
217    {
218        self.deserialize_unit(visitor)
219    }
220
221    fn deserialize_newtype_struct<V>(
222        self,
223        name: &'static str,
224        visitor: V,
225    ) -> Result<V::Value, Self::Error>
226    where
227        V: serde::de::Visitor<'a>,
228    {
229        if name == Reference::NAME {
230            visitor.visit_newtype_struct(FirestoreReferenceValueDeserializer::new(self.value))
231        } else {
232            visitor.visit_newtype_struct(self)
233        }
234    }
235
236    fn deserialize_seq<V>(self, visitor: V) -> Result<V::Value, Self::Error>
237    where
238        V: serde::de::Visitor<'a>,
239    {
240        visitor.visit_seq(FirestoreArrayValueDeserializer::new(self.value)?)
241    }
242
243    fn deserialize_tuple<V>(self, _len: usize, visitor: V) -> Result<V::Value, Self::Error>
244    where
245        V: serde::de::Visitor<'a>,
246    {
247        visitor.visit_seq(FirestoreArrayValueDeserializer::new(self.value)?)
248    }
249
250    fn deserialize_tuple_struct<V>(
251        self,
252        _name: &'static str,
253        _len: usize,
254        visitor: V,
255    ) -> Result<V::Value, Self::Error>
256    where
257        V: serde::de::Visitor<'a>,
258    {
259        visitor.visit_seq(FirestoreArrayValueDeserializer::new(self.value)?)
260    }
261
262    fn deserialize_map<V>(self, visitor: V) -> Result<V::Value, Self::Error>
263    where
264        V: serde::de::Visitor<'a>,
265    {
266        visitor.visit_map(FirestoreMapValueDeserializer::new(self.value)?)
267    }
268
269    fn deserialize_struct<V>(
270        self,
271        name: &'static str,
272        fields: &'static [&'static str],
273        visitor: V,
274    ) -> Result<V::Value, Self::Error>
275    where
276        V: serde::de::Visitor<'a>,
277    {
278        if name == LatLng::NAME {
279            visitor.visit_map(FirestoreGeoPointValueDeserializer::new(self.value)?)
280        } else if name == Timestamp::NAME {
281            visitor.visit_map(FirestoreTimestampValueDeserializer::new(self.value)?)
282        } else {
283            visitor.visit_map(FirestoreStructMapValueDeserializer::new(
284                self.value, fields,
285            )?)
286        }
287    }
288
289    fn deserialize_enum<V>(
290        self,
291        _name: &'static str,
292        variants: &'static [&'static str],
293        visitor: V,
294    ) -> Result<V::Value, Self::Error>
295    where
296        V: serde::de::Visitor<'a>,
297    {
298        visitor.visit_enum(FirestoreEnumDeserializer::new(self.value, variants)?)
299    }
300
301    fn deserialize_identifier<V>(self, visitor: V) -> Result<V::Value, Self::Error>
302    where
303        V: serde::de::Visitor<'a>,
304    {
305        match self.value.value_type()? {
306            ValueType::StringValue(s) => visitor.visit_str(s.as_str()),
307            ValueType::MapValue(_) => {
308                let (variant, _) = self.value.as_variant_value()?;
309                visitor.visit_str(variant.as_str())
310            }
311            _ => todo!(),
312        }
313    }
314
315    fn deserialize_ignored_any<V>(self, visitor: V) -> Result<V::Value, Self::Error>
316    where
317        V: serde::de::Visitor<'a>,
318    {
319        visitor.visit_unit()
320    }
321}
serde_firestore_value/de/firestore_value_deserializer.rs

serde_firestore_value/de/
firestore_value_deserializer.rs
