serde_querystring/de/
traits.rs

1use std::str;
2
3use _serde::{de, forward_to_deserialize_any};
4use lexical::{self, FromLexical};
5
6use crate::decode::Reference;
7
8use super::{
9    error::{Error, ErrorKind},
10    slices::{DecodedSlice, RawSlice, Value},
11};
12
13pub trait IntoDeserializer<'de, 's> {
14    /// The type of the deserializer being converted into.
15    type Deserializer: de::Deserializer<'de, Error = Error>;
16
17    /// Convert this value into a deserializer.
18    fn into_deserializer(self, scratch: &'s mut Vec<u8>) -> Self::Deserializer;
19}
20
21///////////////////////////////////////////////////////////////////////////////////////////////////
22
23impl<'de, 's> IntoDeserializer<'de, 's> for DecodedSlice<'de> {
24    type Deserializer = ValueDeserializer<'s, Self>;
25
26    fn into_deserializer(self, scratch: &'s mut Vec<u8>) -> Self::Deserializer {
27        ValueDeserializer(self, scratch)
28    }
29}
30
31impl<'de, 's> IntoDeserializer<'de, 's> for RawSlice<'de> {
32    type Deserializer = ValueDeserializer<'s, Self>;
33
34    fn into_deserializer(self, scratch: &'s mut Vec<u8>) -> Self::Deserializer {
35        ValueDeserializer(self, scratch)
36    }
37}
38
39impl<'de, 's> IntoDeserializer<'de, 's> for Option<RawSlice<'de>> {
40    type Deserializer = ValueDeserializer<'s, Self>;
41
42    fn into_deserializer(self, scratch: &'s mut Vec<u8>) -> Self::Deserializer {
43        ValueDeserializer(self, scratch)
44    }
45}
46
47///////////////////////////////////////////////////////////////////////////////////////////////////
48
49pub struct ValueDeserializer<'s, T>(T, &'s mut Vec<u8>);
50
51macro_rules! deserialize_number {
52    ($($method:ident => $visit:ident) *) => {
53        $(
54            #[inline]
55            fn $method<V>(self, visitor: V) -> Result<V::Value,Error>
56            where
57                V: de::Visitor<'de>,
58            {
59                visitor.$visit(self.0.parse_number(self.1)?)
60            }
61        )*
62    };
63}
64
65impl<'de, 's, T> de::Deserializer<'de> for ValueDeserializer<'s, T>
66where
67    T: Value<'de>,
68{
69    type Error = Error;
70
71    #[inline]
72    fn deserialize_any<V>(self, visitor: V) -> Result<V::Value, Error>
73    where
74        V: de::Visitor<'de>,
75    {
76        match self.0.parse_str(self.1)? {
77            Reference::Borrowed(b) => visitor.visit_borrowed_str(b),
78            Reference::Copied(o) => visitor.visit_str(o),
79            Reference::Owned(o) => visitor.visit_string(o),
80        }
81    }
82
83    #[inline]
84    fn deserialize_newtype_struct<V>(self, _: &str, visitor: V) -> Result<V::Value, Error>
85    where
86        V: de::Visitor<'de>,
87    {
88        visitor.visit_newtype_struct(self)
89    }
90
91    #[inline]
92    fn deserialize_bool<V>(self, visitor: V) -> Result<V::Value, Error>
93    where
94        V: de::Visitor<'de>,
95    {
96        visitor.visit_bool(self.0.parse_bool(self.1)?)
97    }
98
99    #[inline]
100    fn deserialize_enum<V>(
101        self,
102        _: &'static str,
103        _: &'static [&'static str],
104        visitor: V,
105    ) -> Result<V::Value, Error>
106    where
107        V: de::Visitor<'de>,
108    {
109        visitor.visit_enum(self)
110    }
111
112    #[inline]
113    fn deserialize_option<V>(self, visitor: V) -> Result<V::Value, Error>
114    where
115        V: de::Visitor<'de>,
116    {
117        if self.0.is_none() {
118            visitor.visit_none()
119        } else {
120            visitor.visit_some(self)
121        }
122    }
123
124    #[inline]
125    fn deserialize_ignored_any<V>(self, visitor: V) -> Result<V::Value, Error>
126    where
127        V: de::Visitor<'de>,
128    {
129        visitor.visit_unit()
130    }
131
132    /// We don't check the bytes to be valid utf8
133    #[inline]
134    fn deserialize_bytes<V>(self, visitor: V) -> Result<V::Value, Error>
135    where
136        V: de::Visitor<'de>,
137    {
138        match self.0.parse_bytes(self.1) {
139            Reference::Borrowed(b) => visitor.visit_borrowed_bytes(b),
140            Reference::Copied(c) => visitor.visit_bytes(c),
141            Reference::Owned(o) => visitor.visit_byte_buf(o),
142        }
143    }
144
145    #[inline]
146    fn deserialize_byte_buf<V>(self, visitor: V) -> Result<V::Value, Error>
147    where
148        V: de::Visitor<'de>,
149    {
150        self.deserialize_bytes(visitor)
151    }
152
153    fn deserialize_identifier<V>(self, visitor: V) -> Result<V::Value, Self::Error>
154    where
155        V: de::Visitor<'de>,
156    {
157        self.deserialize_bytes(visitor)
158    }
159
160    forward_to_deserialize_any! {
161        <W: Visitor<'de>>
162        char str string unit unit_struct map struct
163        tuple seq tuple_struct
164    }
165
166    deserialize_number!(
167        deserialize_i8 => visit_i8
168        deserialize_i16 => visit_i16
169        deserialize_i32 => visit_i32
170        deserialize_i64 => visit_i64
171
172        deserialize_u8 => visit_u8
173        deserialize_u16 => visit_u16
174        deserialize_u32 => visit_u32
175        deserialize_u64 => visit_u64
176
177        deserialize_f32 => visit_f32
178        deserialize_f64 => visit_f64
179    );
180}
181
182impl<'de, 's, T> de::EnumAccess<'de> for ValueDeserializer<'s, T>
183where
184    T: Value<'de>,
185{
186    type Error = Error;
187    type Variant = UnitOnly;
188
189    fn variant_seed<V>(self, seed: V) -> Result<(V::Value, Self::Variant), Self::Error>
190    where
191        V: de::DeserializeSeed<'de>,
192    {
193        seed.deserialize(self).map(|res| (res, UnitOnly))
194    }
195}
196
197///////////////////////////////////////////////////////////////////////////////////////////////////
198
199pub trait IntoRawSlices<'de> {
200    type SizedIterator: Iterator<Item = RawSlice<'de>>;
201    type UnSizedIterator: Iterator<Item = RawSlice<'de>>;
202
203    fn into_sized_iterator(self, size: usize) -> Result<Self::SizedIterator, Error>;
204    fn into_unsized_iterator(self) -> Self::UnSizedIterator;
205    fn into_single_slice(self) -> RawSlice<'de>;
206}
207
208impl<'de, 's, I> IntoDeserializer<'de, 's> for I
209where
210    I: 'de + IntoRawSlices<'de>,
211{
212    type Deserializer = IterDeserializer<'s, I>;
213
214    fn into_deserializer(self, scratch: &'s mut Vec<u8>) -> Self::Deserializer {
215        IterDeserializer(self, scratch)
216    }
217}
218
219pub struct IterDeserializer<'s, I>(I, &'s mut Vec<u8>);
220
221impl<'de, 's, I> IterDeserializer<'s, I>
222where
223    I: 'de + IntoRawSlices<'de>,
224{
225    fn parse_number<T>(self) -> Result<T, Error>
226    where
227        T: FromLexical,
228    {
229        self.0.into_single_slice().parse_number(self.1)
230    }
231
232    #[inline]
233    fn into_slice_deserializer(self) -> ValueDeserializer<'s, RawSlice<'de>> {
234        ValueDeserializer(self.0.into_single_slice(), self.1)
235    }
236}
237
238macro_rules! deserialize_number {
239    ($($method:ident => $visit:ident) *) => {
240        $(
241            #[inline]
242            fn $method<V>(self, visitor: V) -> Result<V::Value,Error>
243            where
244                V: de::Visitor<'de>,
245            {
246                visitor.$visit(self.parse_number()?)
247            }
248        )*
249    };
250}
251
252impl<'de, 's, I> de::Deserializer<'de> for IterDeserializer<'s, I>
253where
254    I: 'de + IntoRawSlices<'de>,
255{
256    type Error = Error;
257
258    #[inline]
259    fn deserialize_any<V>(self, visitor: V) -> Result<V::Value, Error>
260    where
261        V: de::Visitor<'de>,
262    {
263        self.into_slice_deserializer().deserialize_any(visitor)
264    }
265
266    #[inline]
267    fn deserialize_newtype_struct<V>(self, _: &str, visitor: V) -> Result<V::Value, Error>
268    where
269        V: de::Visitor<'de>,
270    {
271        visitor.visit_newtype_struct(self)
272    }
273
274    #[inline]
275    fn deserialize_bool<V>(self, visitor: V) -> Result<V::Value, Error>
276    where
277        V: de::Visitor<'de>,
278    {
279        self.into_slice_deserializer().deserialize_bool(visitor)
280    }
281
282    #[inline]
283    fn deserialize_enum<V>(
284        self,
285        name: &'static str,
286        variants: &'static [&'static str],
287        visitor: V,
288    ) -> Result<V::Value, Error>
289    where
290        V: de::Visitor<'de>,
291    {
292        self.into_slice_deserializer()
293            .deserialize_enum(name, variants, visitor)
294    }
295
296    #[inline]
297    fn deserialize_option<V>(self, visitor: V) -> Result<V::Value, Error>
298    where
299        V: de::Visitor<'de>,
300    {
301        visitor.visit_some(self)
302    }
303
304    #[inline]
305    fn deserialize_ignored_any<V>(self, visitor: V) -> Result<V::Value, Error>
306    where
307        V: de::Visitor<'de>,
308    {
309        visitor.visit_unit()
310    }
311
312    /// We don't check the bytes to be valid utf8
313    #[inline]
314    fn deserialize_bytes<V>(self, visitor: V) -> Result<V::Value, Error>
315    where
316        V: de::Visitor<'de>,
317    {
318        self.into_slice_deserializer().deserialize_bytes(visitor)
319    }
320
321    #[inline]
322    fn deserialize_byte_buf<V>(self, visitor: V) -> Result<V::Value, Error>
323    where
324        V: de::Visitor<'de>,
325    {
326        self.deserialize_bytes(visitor)
327    }
328
329    fn deserialize_seq<V>(self, visitor: V) -> Result<V::Value, Self::Error>
330    where
331        V: de::Visitor<'de>,
332    {
333        visitor.visit_seq(SizedIterDeserializer(
334            self.0.into_unsized_iterator(),
335            self.1,
336        ))
337    }
338
339    fn deserialize_tuple<V>(self, len: usize, visitor: V) -> Result<V::Value, Self::Error>
340    where
341        V: de::Visitor<'de>,
342    {
343        visitor.visit_seq(SizedIterDeserializer(
344            self.0.into_sized_iterator(len)?,
345            self.1,
346        ))
347    }
348
349    fn deserialize_tuple_struct<V>(
350        self,
351        _: &'static str,
352        len: usize,
353        visitor: V,
354    ) -> Result<V::Value, Self::Error>
355    where
356        V: de::Visitor<'de>,
357    {
358        visitor.visit_seq(SizedIterDeserializer(
359            self.0.into_sized_iterator(len)?,
360            self.1,
361        ))
362    }
363
364    forward_to_deserialize_any! {
365        <W: Visitor<'de>>
366        char str string unit unit_struct map struct identifier
367    }
368
369    deserialize_number!(
370        deserialize_i8 => visit_i8
371        deserialize_i16 => visit_i16
372        deserialize_i32 => visit_i32
373        deserialize_i64 => visit_i64
374
375        deserialize_u8 => visit_u8
376        deserialize_u16 => visit_u16
377        deserialize_u32 => visit_u32
378        deserialize_u64 => visit_u64
379
380        deserialize_f32 => visit_f32
381        deserialize_f64 => visit_f64
382    );
383}
384
385struct SizedIterDeserializer<'s, I>(I, &'s mut Vec<u8>);
386
387impl<'de, 's, I> de::SeqAccess<'de> for SizedIterDeserializer<'s, I>
388where
389    I: 'de + Iterator<Item = RawSlice<'de>>,
390{
391    type Error = Error;
392
393    fn next_element_seed<T>(&mut self, seed: T) -> Result<Option<T::Value>, Self::Error>
394    where
395        T: de::DeserializeSeed<'de>,
396    {
397        self.0
398            .next()
399            .map(|v| seed.deserialize(v.into_deserializer(self.1)))
400            .transpose()
401    }
402}
403
404pub struct UnitOnly;
405
406impl<'de> de::VariantAccess<'de> for UnitOnly {
407    type Error = Error;
408
409    fn unit_variant(self) -> Result<(), Self::Error> {
410        Ok(())
411    }
412
413    #[cold]
414    fn tuple_variant<V>(self, _len: usize, _visitor: V) -> Result<V::Value, Self::Error>
415    where
416        V: de::Visitor<'de>,
417    {
418        Err(Error::new(ErrorKind::InvalidType)
419            .message(String::from("Tuple enums are not supported")))
420    }
421
422    #[cold]
423    fn struct_variant<V>(
424        self,
425        _fields: &'static [&'static str],
426        _visitor: V,
427    ) -> Result<V::Value, Self::Error>
428    where
429        V: de::Visitor<'de>,
430    {
431        Err(Error::new(ErrorKind::InvalidType)
432            .message(String::from("Struct enums are not supported")))
433    }
434
435    #[cold]
436    fn newtype_variant_seed<T>(self, _seed: T) -> Result<T::Value, Self::Error>
437    where
438        T: de::DeserializeSeed<'de>,
439    {
440        Err(Error::new(ErrorKind::InvalidType)
441            .message(String::from("NewType enums are not supported")))
442    }
443}
serde_querystring/de/traits.rs

serde_querystring/de/
traits.rs
