serde_querystring/de/
mod.rs

1mod error;
2mod slices;
3mod traits;
4
5use _serde::{de, forward_to_deserialize_any};
6
7pub use error::{Error, ErrorKind};
8
9pub(crate) mod __implementors {
10    pub(crate) use super::slices::{DecodedSlice, RawSlice};
11    pub(crate) use super::traits::{IntoDeserializer, IntoRawSlices};
12}
13
14use crate::parsers::{BracketsQS, DelimiterQS, DuplicateQS, UrlEncodedQS};
15
16pub(crate) struct QSDeserializer<I, T> {
17    iter: I,
18    value: Option<T>,
19    scratch: Vec<u8>,
20}
21
22impl<I, T> QSDeserializer<I, T> {
23    pub fn new(iter: I) -> Self {
24        Self {
25            iter,
26            value: None,
27            scratch: Vec::new(),
28        }
29    }
30}
31
32impl<'de, I, E, A> de::Deserializer<'de> for QSDeserializer<I, A>
33where
34    I: Iterator<Item = (E, A)>,
35    for<'s> E: __implementors::IntoDeserializer<'de, 's>,
36    for<'s> A: __implementors::IntoDeserializer<'de, 's>,
37{
38    type Error = Error;
39
40    fn deserialize_any<V>(self, visitor: V) -> Result<V::Value, Self::Error>
41    where
42        V: de::Visitor<'de>,
43    {
44        visitor.visit_map(self)
45    }
46
47    forward_to_deserialize_any! {
48        bool i8 i16 i32 i64 i128 u8 u16 u32 u64 u128 f32 f64 char str string
49        bytes byte_buf option unit unit_struct newtype_struct seq tuple
50        tuple_struct map struct enum identifier ignored_any
51    }
52}
53
54impl<'de, I, E, A> de::MapAccess<'de> for QSDeserializer<I, A>
55where
56    I: Iterator<Item = (E, A)>,
57    for<'s> E: __implementors::IntoDeserializer<'de, 's>,
58    for<'s> A: __implementors::IntoDeserializer<'de, 's>,
59{
60    type Error = Error;
61
62    fn next_key_seed<K>(&mut self, seed: K) -> Result<Option<K::Value>, Self::Error>
63    where
64        K: de::DeserializeSeed<'de>,
65    {
66        let mut scratch = Vec::new();
67
68        if let Some((k, v)) = self.iter.next() {
69            self.value = Some(v);
70            seed.deserialize(k.into_deserializer(&mut scratch))
71                .map(Some)
72        } else {
73            Ok(None)
74        }
75    }
76
77    fn next_value_seed<V>(&mut self, seed: V) -> Result<V::Value, Self::Error>
78    where
79        V: de::DeserializeSeed<'de>,
80    {
81        let value = self
82            .value
83            .take()
84            .expect("Method next_value called before next_key");
85        seed.deserialize(value.into_deserializer(&mut self.scratch))
86    }
87
88    fn size_hint(&self) -> Option<usize> {
89        self.iter.size_hint().1
90    }
91}
92
93/// An enum used to choose the parsing method for deserialization
94#[derive(Clone, Copy)]
95pub enum ParseMode {
96    /// The simplest parser for querystring.
97    /// It parses the whole querystring, and overwrites each repeated key’s value.
98    /// It does not support vectors, maps nor tuples, but provides the best performance.
99    ///
100    /// More description at ([UrlEncodedQs](crate::UrlEncodedQS))
101    UrlEncoded,
102
103    /// A querystring parser with support for vectors/lists of values by repeating keys.
104    /// (ex. `"key=value1&key=value2"`)
105    ///
106    /// More description at ([DuplicateQs](crate::DuplicateQS))
107    Duplicate,
108
109    /// A querystring parser with support for vectors/lists of values by the use of a delimiter byte.
110    /// (ex. `"key=value1|value2|value3"`). Holds the delimiter as a single byte `Delimiter(b'|')`
111    ///
112    /// More description at ([DelimiterQs](crate::DelimiterQS))
113    Delimiter(u8),
114
115    /// A querystring parser with support for vectors/lists, maps and enums
116    /// by the use of brackets(like qs or PHP).(ex. `key[2]=value2&key[1]=value1"`)
117    ///
118    /// More description at ([BracketsQs](crate::BracketsQS))
119    Brackets,
120}
121
122/// Deserialize an instance of type `T` from bytes of query string.
123pub fn from_bytes<'de, T>(input: &'de [u8], config: ParseMode) -> Result<T, Error>
124where
125    T: de::Deserialize<'de>,
126{
127    match config {
128        ParseMode::UrlEncoded => {
129            // A simple key=value parser
130            T::deserialize(QSDeserializer::new(UrlEncodedQS::parse(input).into_iter()))
131        }
132        ParseMode::Duplicate => {
133            // A parser with duplicated keys interpreted as sequence
134            T::deserialize(QSDeserializer::new(DuplicateQS::parse(input).into_iter()))
135        }
136        ParseMode::Delimiter(s) => {
137            // A parser with sequences of values seperated by one character
138            T::deserialize(QSDeserializer::new(
139                DelimiterQS::parse(input, s).into_iter(),
140            ))
141        }
142        ParseMode::Brackets => {
143            // A PHP like interpretation of querystrings
144            T::deserialize(QSDeserializer::new(BracketsQS::parse(input).into_iter()))
145        }
146    }
147}
148
149/// Deserialize an instance of type `T` from a query string.
150pub fn from_str<'de, T>(input: &'de str, config: ParseMode) -> Result<T, Error>
151where
152    T: de::Deserialize<'de>,
153{
154    from_bytes(input.as_bytes(), config)
155}
serde_querystring/de/mod.rs

serde_querystring/de/
mod.rs
