serde/de/ignored_any.rs
1use lib::*;
2
3use de::{
4 Deserialize, Deserializer, EnumAccess, Error, MapAccess, SeqAccess, VariantAccess, Visitor,
5};
6
7/// An efficient way of discarding data from a deserializer.
8///
9/// Think of this like `serde_json::Value` in that it can be deserialized from
10/// any type, except that it does not store any information about the data that
11/// gets deserialized.
12///
13/// ```edition2018
14/// use std::fmt;
15/// use std::marker::PhantomData;
16///
17/// use serde::de::{
18/// self, Deserialize, DeserializeSeed, Deserializer, IgnoredAny, SeqAccess, Visitor,
19/// };
20///
21/// /// A seed that can be used to deserialize only the `n`th element of a sequence
22/// /// while efficiently discarding elements of any type before or after index `n`.
23/// ///
24/// /// For example to deserialize only the element at index 3:
25/// ///
26/// /// ```
27/// /// NthElement::new(3).deserialize(deserializer)
28/// /// ```
29/// pub struct NthElement<T> {
30/// n: usize,
31/// marker: PhantomData<T>,
32/// }
33///
34/// impl<T> NthElement<T> {
35/// pub fn new(n: usize) -> Self {
36/// NthElement {
37/// n: n,
38/// marker: PhantomData,
39/// }
40/// }
41/// }
42///
43/// impl<'de, T> Visitor<'de> for NthElement<T>
44/// where
45/// T: Deserialize<'de>,
46/// {
47/// type Value = T;
48///
49/// fn expecting(&self, formatter: &mut fmt::Formatter) -> fmt::Result {
50/// write!(
51/// formatter,
52/// "a sequence in which we care about element {}",
53/// self.n
54/// )
55/// }
56///
57/// fn visit_seq<A>(self, mut seq: A) -> Result<Self::Value, A::Error>
58/// where
59/// A: SeqAccess<'de>,
60/// {
61/// // Skip over the first `n` elements.
62/// for i in 0..self.n {
63/// // It is an error if the sequence ends before we get to element `n`.
64/// if seq.next_element::<IgnoredAny>()?.is_none() {
65/// return Err(de::Error::invalid_length(i, &self));
66/// }
67/// }
68///
69/// // Deserialize the one we care about.
70/// let nth = match seq.next_element()? {
71/// Some(nth) => nth,
72/// None => {
73/// return Err(de::Error::invalid_length(self.n, &self));
74/// }
75/// };
76///
77/// // Skip over any remaining elements in the sequence after `n`.
78/// while let Some(IgnoredAny) = seq.next_element()? {
79/// // ignore
80/// }
81///
82/// Ok(nth)
83/// }
84/// }
85///
86/// impl<'de, T> DeserializeSeed<'de> for NthElement<T>
87/// where
88/// T: Deserialize<'de>,
89/// {
90/// type Value = T;
91///
92/// fn deserialize<D>(self, deserializer: D) -> Result<Self::Value, D::Error>
93/// where
94/// D: Deserializer<'de>,
95/// {
96/// deserializer.deserialize_seq(self)
97/// }
98/// }
99///
100/// # fn example<'de, D>(deserializer: D) -> Result<(), D::Error>
101/// # where
102/// # D: Deserializer<'de>,
103/// # {
104/// // Deserialize only the sequence element at index 3 from this deserializer.
105/// // The element at index 3 is required to be a string. Elements before and
106/// // after index 3 are allowed to be of any type.
107/// let s: String = NthElement::new(3).deserialize(deserializer)?;
108/// # Ok(())
109/// # }
110/// ```
111#[derive(Copy, Clone, Debug, Default)]
112pub struct IgnoredAny;
113
114impl<'de> Visitor<'de> for IgnoredAny {
115 type Value = IgnoredAny;
116
117 fn expecting(&self, formatter: &mut fmt::Formatter) -> fmt::Result {
118 formatter.write_str("anything at all")
119 }
120
121 #[inline]
122 fn visit_bool<E>(self, x: bool) -> Result<Self::Value, E> {
123 let _ = x;
124 Ok(IgnoredAny)
125 }
126
127 #[inline]
128 fn visit_i64<E>(self, x: i64) -> Result<Self::Value, E> {
129 let _ = x;
130 Ok(IgnoredAny)
131 }
132
133 #[inline]
134 fn visit_u64<E>(self, x: u64) -> Result<Self::Value, E> {
135 let _ = x;
136 Ok(IgnoredAny)
137 }
138
139 #[inline]
140 fn visit_f64<E>(self, x: f64) -> Result<Self::Value, E> {
141 let _ = x;
142 Ok(IgnoredAny)
143 }
144
145 #[inline]
146 fn visit_str<E>(self, s: &str) -> Result<Self::Value, E>
147 where
148 E: Error,
149 {
150 let _ = s;
151 Ok(IgnoredAny)
152 }
153
154 #[inline]
155 fn visit_none<E>(self) -> Result<Self::Value, E> {
156 Ok(IgnoredAny)
157 }
158
159 #[inline]
160 fn visit_some<D>(self, deserializer: D) -> Result<Self::Value, D::Error>
161 where
162 D: Deserializer<'de>,
163 {
164 IgnoredAny::deserialize(deserializer)
165 }
166
167 #[inline]
168 fn visit_newtype_struct<D>(self, deserializer: D) -> Result<Self::Value, D::Error>
169 where
170 D: Deserializer<'de>,
171 {
172 IgnoredAny::deserialize(deserializer)
173 }
174
175 #[inline]
176 fn visit_unit<E>(self) -> Result<Self::Value, E> {
177 Ok(IgnoredAny)
178 }
179
180 #[inline]
181 fn visit_seq<A>(self, mut seq: A) -> Result<Self::Value, A::Error>
182 where
183 A: SeqAccess<'de>,
184 {
185 while let Some(IgnoredAny) = try!(seq.next_element()) {
186 // Gobble
187 }
188 Ok(IgnoredAny)
189 }
190
191 #[inline]
192 fn visit_map<A>(self, mut map: A) -> Result<Self::Value, A::Error>
193 where
194 A: MapAccess<'de>,
195 {
196 while let Some((IgnoredAny, IgnoredAny)) = try!(map.next_entry()) {
197 // Gobble
198 }
199 Ok(IgnoredAny)
200 }
201
202 #[inline]
203 fn visit_bytes<E>(self, bytes: &[u8]) -> Result<Self::Value, E>
204 where
205 E: Error,
206 {
207 let _ = bytes;
208 Ok(IgnoredAny)
209 }
210
211 fn visit_enum<A>(self, data: A) -> Result<Self::Value, A::Error>
212 where
213 A: EnumAccess<'de>,
214 {
215 data.variant::<IgnoredAny>()?.1.newtype_variant()
216 }
217}
218
219impl<'de> Deserialize<'de> for IgnoredAny {
220 #[inline]
221 fn deserialize<D>(deserializer: D) -> Result<IgnoredAny, D::Error>
222 where
223 D: Deserializer<'de>,
224 {
225 deserializer.deserialize_ignored_any(IgnoredAny)
226 }
227}