]>
Commit | Line | Data |
---|---|---|
7cac9316 XL |
1 | //! Deserialize JSON data to a Rust data structure. |
2 | ||
f035d41b XL |
3 | use crate::error::{Error, ErrorCode, Result}; |
4 | #[cfg(feature = "float_roundtrip")] | |
5 | use crate::lexical; | |
6 | use crate::lib::str::FromStr; | |
7 | use crate::lib::*; | |
8 | use crate::number::Number; | |
9 | use crate::read::{self, Fused, Reference}; | |
ff7c6d11 | 10 | use serde::de::{self, Expected, Unexpected}; |
f035d41b | 11 | use serde::{forward_to_deserialize_any, serde_if_integer128}; |
7cac9316 | 12 | |
f035d41b XL |
13 | #[cfg(feature = "arbitrary_precision")] |
14 | use crate::number::NumberDeserializer; | |
7cac9316 | 15 | |
f035d41b | 16 | pub use crate::read::{Read, SliceRead, StrRead}; |
7cac9316 | 17 | |
f035d41b XL |
18 | #[cfg(feature = "std")] |
19 | pub use crate::read::IoRead; | |
0531ce1d | 20 | |
7cac9316 XL |
21 | ////////////////////////////////////////////////////////////////////////////// |
22 | ||
23 | /// A structure that deserializes JSON into Rust values. | |
24 | pub struct Deserializer<R> { | |
25 | read: R, | |
0bf4aa26 | 26 | scratch: Vec<u8>, |
7cac9316 | 27 | remaining_depth: u8, |
f035d41b XL |
28 | #[cfg(feature = "float_roundtrip")] |
29 | single_precision: bool, | |
416331ca XL |
30 | #[cfg(feature = "unbounded_depth")] |
31 | disable_recursion_limit: bool, | |
7cac9316 XL |
32 | } |
33 | ||
041b39d2 XL |
34 | impl<'de, R> Deserializer<R> |
35 | where | |
36 | R: read::Read<'de>, | |
7cac9316 XL |
37 | { |
38 | /// Create a JSON deserializer from one of the possible serde_json input | |
39 | /// sources. | |
40 | /// | |
41 | /// Typically it is more convenient to use one of these methods instead: | |
42 | /// | |
43 | /// - Deserializer::from_str | |
6a06907d | 44 | /// - Deserializer::from_slice |
7cac9316 XL |
45 | /// - Deserializer::from_reader |
46 | pub fn new(read: R) -> Self { | |
f035d41b XL |
47 | Deserializer { |
48 | read, | |
49 | scratch: Vec::new(), | |
50 | remaining_depth: 128, | |
51 | #[cfg(feature = "float_roundtrip")] | |
52 | single_precision: false, | |
53 | #[cfg(feature = "unbounded_depth")] | |
54 | disable_recursion_limit: false, | |
7cac9316 XL |
55 | } |
56 | } | |
57 | } | |
58 | ||
f035d41b | 59 | #[cfg(feature = "std")] |
7cac9316 | 60 | impl<R> Deserializer<read::IoRead<R>> |
041b39d2 | 61 | where |
f035d41b | 62 | R: crate::io::Read, |
7cac9316 XL |
63 | { |
64 | /// Creates a JSON deserializer from an `io::Read`. | |
f035d41b XL |
65 | /// |
66 | /// Reader-based deserializers do not support deserializing borrowed types | |
67 | /// like `&str`, since the `std::io::Read` trait has no non-copying methods | |
68 | /// -- everything it does involves copying bytes out of the data source. | |
7cac9316 XL |
69 | pub fn from_reader(reader: R) -> Self { |
70 | Deserializer::new(read::IoRead::new(reader)) | |
71 | } | |
72 | } | |
73 | ||
74 | impl<'a> Deserializer<read::SliceRead<'a>> { | |
75 | /// Creates a JSON deserializer from a `&[u8]`. | |
76 | pub fn from_slice(bytes: &'a [u8]) -> Self { | |
77 | Deserializer::new(read::SliceRead::new(bytes)) | |
78 | } | |
79 | } | |
80 | ||
81 | impl<'a> Deserializer<read::StrRead<'a>> { | |
82 | /// Creates a JSON deserializer from a `&str`. | |
83 | pub fn from_str(s: &'a str) -> Self { | |
84 | Deserializer::new(read::StrRead::new(s)) | |
85 | } | |
86 | } | |
87 | ||
88 | macro_rules! overflow { | |
89 | ($a:ident * 10 + $b:ident, $c:expr) => { | |
90 | $a >= $c / 10 && ($a > $c / 10 || $b > $c % 10) | |
83c7162d | 91 | }; |
7cac9316 XL |
92 | } |
93 | ||
f035d41b | 94 | pub(crate) enum ParserNumber { |
041b39d2 XL |
95 | F64(f64), |
96 | U64(u64), | |
97 | I64(i64), | |
0531ce1d XL |
98 | #[cfg(feature = "arbitrary_precision")] |
99 | String(String), | |
041b39d2 XL |
100 | } |
101 | ||
8faf50e0 | 102 | impl ParserNumber { |
041b39d2 XL |
103 | fn visit<'de, V>(self, visitor: V) -> Result<V::Value> |
104 | where | |
105 | V: de::Visitor<'de>, | |
106 | { | |
107 | match self { | |
8faf50e0 XL |
108 | ParserNumber::F64(x) => visitor.visit_f64(x), |
109 | ParserNumber::U64(x) => visitor.visit_u64(x), | |
110 | ParserNumber::I64(x) => visitor.visit_i64(x), | |
0531ce1d | 111 | #[cfg(feature = "arbitrary_precision")] |
8faf50e0 | 112 | ParserNumber::String(x) => visitor.visit_map(NumberDeserializer { number: x.into() }), |
041b39d2 XL |
113 | } |
114 | } | |
ff7c6d11 | 115 | |
f035d41b | 116 | fn invalid_type(self, exp: &dyn Expected) -> Error { |
ff7c6d11 | 117 | match self { |
8faf50e0 XL |
118 | ParserNumber::F64(x) => de::Error::invalid_type(Unexpected::Float(x), exp), |
119 | ParserNumber::U64(x) => de::Error::invalid_type(Unexpected::Unsigned(x), exp), | |
120 | ParserNumber::I64(x) => de::Error::invalid_type(Unexpected::Signed(x), exp), | |
0531ce1d | 121 | #[cfg(feature = "arbitrary_precision")] |
8faf50e0 | 122 | ParserNumber::String(_) => de::Error::invalid_type(Unexpected::Other("number"), exp), |
ff7c6d11 XL |
123 | } |
124 | } | |
041b39d2 XL |
125 | } |
126 | ||
127 | impl<'de, R: Read<'de>> Deserializer<R> { | |
7cac9316 XL |
128 | /// The `Deserializer::end` method should be called after a value has been fully deserialized. |
129 | /// This allows the `Deserializer` to validate that the input stream is at the end or that it | |
130 | /// only has trailing whitespace. | |
131 | pub fn end(&mut self) -> Result<()> { | |
f035d41b | 132 | match tri!(self.parse_whitespace()) { |
041b39d2 XL |
133 | Some(_) => Err(self.peek_error(ErrorCode::TrailingCharacters)), |
134 | None => Ok(()), | |
7cac9316 XL |
135 | } |
136 | } | |
137 | ||
138 | /// Turn a JSON deserializer into an iterator over values of type T. | |
041b39d2 XL |
139 | pub fn into_iter<T>(self) -> StreamDeserializer<'de, R, T> |
140 | where | |
141 | T: de::Deserialize<'de>, | |
7cac9316 XL |
142 | { |
143 | // This cannot be an implementation of std::iter::IntoIterator because | |
144 | // we need the caller to choose what T is. | |
041b39d2 | 145 | let offset = self.read.byte_offset(); |
7cac9316 XL |
146 | StreamDeserializer { |
147 | de: self, | |
f035d41b XL |
148 | offset, |
149 | failed: false, | |
041b39d2 XL |
150 | output: PhantomData, |
151 | lifetime: PhantomData, | |
7cac9316 XL |
152 | } |
153 | } | |
154 | ||
416331ca XL |
155 | /// Parse arbitrarily deep JSON structures without any consideration for |
156 | /// overflowing the stack. | |
157 | /// | |
158 | /// You will want to provide some other way to protect against stack | |
159 | /// overflows, such as by wrapping your Deserializer in the dynamically | |
160 | /// growing stack adapter provided by the serde_stacker crate. Additionally | |
161 | /// you will need to be careful around other recursive operations on the | |
162 | /// parsed result which may overflow the stack after deserialization has | |
163 | /// completed, including, but not limited to, Display and Debug and Drop | |
164 | /// impls. | |
165 | /// | |
166 | /// *This method is only available if serde_json is built with the | |
167 | /// `"unbounded_depth"` feature.* | |
168 | /// | |
169 | /// # Examples | |
170 | /// | |
f035d41b | 171 | /// ``` |
416331ca XL |
172 | /// use serde::Deserialize; |
173 | /// use serde_json::Value; | |
174 | /// | |
175 | /// fn main() { | |
176 | /// let mut json = String::new(); | |
177 | /// for _ in 0..10000 { | |
178 | /// json = format!("[{}]", json); | |
179 | /// } | |
180 | /// | |
181 | /// let mut deserializer = serde_json::Deserializer::from_str(&json); | |
182 | /// deserializer.disable_recursion_limit(); | |
183 | /// let deserializer = serde_stacker::Deserializer::new(&mut deserializer); | |
184 | /// let value = Value::deserialize(deserializer).unwrap(); | |
185 | /// | |
186 | /// carefully_drop_nested_arrays(value); | |
187 | /// } | |
188 | /// | |
189 | /// fn carefully_drop_nested_arrays(value: Value) { | |
190 | /// let mut stack = vec![value]; | |
191 | /// while let Some(value) = stack.pop() { | |
192 | /// if let Value::Array(array) = value { | |
193 | /// stack.extend(array); | |
194 | /// } | |
195 | /// } | |
196 | /// } | |
197 | /// ``` | |
198 | #[cfg(feature = "unbounded_depth")] | |
94222f64 | 199 | #[cfg_attr(docsrs, doc(cfg(feature = "unbounded_depth")))] |
416331ca XL |
200 | pub fn disable_recursion_limit(&mut self) { |
201 | self.disable_recursion_limit = true; | |
202 | } | |
203 | ||
7cac9316 | 204 | fn peek(&mut self) -> Result<Option<u8>> { |
0731742a | 205 | self.read.peek() |
7cac9316 XL |
206 | } |
207 | ||
208 | fn peek_or_null(&mut self) -> Result<u8> { | |
f035d41b | 209 | Ok(tri!(self.peek()).unwrap_or(b'\x00')) |
7cac9316 XL |
210 | } |
211 | ||
212 | fn eat_char(&mut self) { | |
213 | self.read.discard(); | |
214 | } | |
215 | ||
216 | fn next_char(&mut self) -> Result<Option<u8>> { | |
0731742a | 217 | self.read.next() |
7cac9316 XL |
218 | } |
219 | ||
220 | fn next_char_or_null(&mut self) -> Result<u8> { | |
f035d41b | 221 | Ok(tri!(self.next_char()).unwrap_or(b'\x00')) |
7cac9316 XL |
222 | } |
223 | ||
224 | /// Error caused by a byte from next_char(). | |
ff7c6d11 XL |
225 | #[cold] |
226 | fn error(&self, reason: ErrorCode) -> Error { | |
83c7162d XL |
227 | let position = self.read.position(); |
228 | Error::syntax(reason, position.line, position.column) | |
7cac9316 XL |
229 | } |
230 | ||
231 | /// Error caused by a byte from peek(). | |
ff7c6d11 XL |
232 | #[cold] |
233 | fn peek_error(&self, reason: ErrorCode) -> Error { | |
83c7162d XL |
234 | let position = self.read.peek_position(); |
235 | Error::syntax(reason, position.line, position.column) | |
7cac9316 XL |
236 | } |
237 | ||
041b39d2 XL |
238 | /// Returns the first non-whitespace byte without consuming it, or `None` if |
239 | /// EOF is encountered. | |
240 | fn parse_whitespace(&mut self) -> Result<Option<u8>> { | |
7cac9316 | 241 | loop { |
f035d41b | 242 | match tri!(self.peek()) { |
041b39d2 XL |
243 | Some(b' ') | Some(b'\n') | Some(b'\t') | Some(b'\r') => { |
244 | self.eat_char(); | |
245 | } | |
246 | other => { | |
247 | return Ok(other); | |
248 | } | |
7cac9316 XL |
249 | } |
250 | } | |
251 | } | |
252 | ||
ff7c6d11 | 253 | #[cold] |
f035d41b | 254 | fn peek_invalid_type(&mut self, exp: &dyn Expected) -> Error { |
ff7c6d11 | 255 | let err = match self.peek_or_null().unwrap_or(b'\x00') { |
7cac9316 XL |
256 | b'n' => { |
257 | self.eat_char(); | |
ff7c6d11 XL |
258 | if let Err(err) = self.parse_ident(b"ull") { |
259 | return err; | |
260 | } | |
261 | de::Error::invalid_type(Unexpected::Unit, exp) | |
7cac9316 XL |
262 | } |
263 | b't' => { | |
264 | self.eat_char(); | |
ff7c6d11 XL |
265 | if let Err(err) = self.parse_ident(b"rue") { |
266 | return err; | |
267 | } | |
268 | de::Error::invalid_type(Unexpected::Bool(true), exp) | |
7cac9316 XL |
269 | } |
270 | b'f' => { | |
271 | self.eat_char(); | |
ff7c6d11 XL |
272 | if let Err(err) = self.parse_ident(b"alse") { |
273 | return err; | |
274 | } | |
275 | de::Error::invalid_type(Unexpected::Bool(false), exp) | |
7cac9316 XL |
276 | } |
277 | b'-' => { | |
278 | self.eat_char(); | |
0531ce1d | 279 | match self.parse_any_number(false) { |
ff7c6d11 XL |
280 | Ok(n) => n.invalid_type(exp), |
281 | Err(err) => return err, | |
282 | } | |
283 | } | |
f035d41b | 284 | b'0'..=b'9' => match self.parse_any_number(true) { |
83c7162d XL |
285 | Ok(n) => n.invalid_type(exp), |
286 | Err(err) => return err, | |
287 | }, | |
7cac9316 XL |
288 | b'"' => { |
289 | self.eat_char(); | |
0bf4aa26 XL |
290 | self.scratch.clear(); |
291 | match self.read.parse_str(&mut self.scratch) { | |
ff7c6d11 XL |
292 | Ok(s) => de::Error::invalid_type(Unexpected::Str(&s), exp), |
293 | Err(err) => return err, | |
041b39d2 | 294 | } |
7cac9316 | 295 | } |
83c7162d XL |
296 | b'[' => de::Error::invalid_type(Unexpected::Seq, exp), |
297 | b'{' => de::Error::invalid_type(Unexpected::Map, exp), | |
ff7c6d11 XL |
298 | _ => self.peek_error(ErrorCode::ExpectedSomeValue), |
299 | }; | |
7cac9316 | 300 | |
ff7c6d11 XL |
301 | self.fix_position(err) |
302 | } | |
7cac9316 | 303 | |
f035d41b | 304 | fn deserialize_number<V>(&mut self, visitor: V) -> Result<V::Value> |
ff7c6d11 XL |
305 | where |
306 | V: de::Visitor<'de>, | |
307 | { | |
f035d41b | 308 | let peek = match tri!(self.parse_whitespace()) { |
ff7c6d11 XL |
309 | Some(b) => b, |
310 | None => { | |
311 | return Err(self.peek_error(ErrorCode::EofWhileParsingValue)); | |
312 | } | |
313 | }; | |
7cac9316 | 314 | |
ff7c6d11 XL |
315 | let value = match peek { |
316 | b'-' => { | |
317 | self.eat_char(); | |
f035d41b | 318 | tri!(self.parse_integer(false)).visit(visitor) |
7cac9316 | 319 | } |
f035d41b | 320 | b'0'..=b'9' => tri!(self.parse_integer(true)).visit(visitor), |
ff7c6d11 | 321 | _ => Err(self.peek_invalid_type(&visitor)), |
7cac9316 XL |
322 | }; |
323 | ||
324 | match value { | |
325 | Ok(value) => Ok(value), | |
ff7c6d11 | 326 | Err(err) => Err(self.fix_position(err)), |
7cac9316 XL |
327 | } |
328 | } | |
329 | ||
8faf50e0 XL |
330 | serde_if_integer128! { |
331 | fn scan_integer128(&mut self, buf: &mut String) -> Result<()> { | |
f035d41b | 332 | match tri!(self.next_char_or_null()) { |
8faf50e0 XL |
333 | b'0' => { |
334 | buf.push('0'); | |
335 | // There can be only one leading '0'. | |
f035d41b XL |
336 | match tri!(self.peek_or_null()) { |
337 | b'0'..=b'9' => { | |
8faf50e0 XL |
338 | Err(self.peek_error(ErrorCode::InvalidNumber)) |
339 | } | |
340 | _ => Ok(()), | |
341 | } | |
342 | } | |
f035d41b | 343 | c @ b'1'..=b'9' => { |
8faf50e0 | 344 | buf.push(c as char); |
f035d41b | 345 | while let c @ b'0'..=b'9' = tri!(self.peek_or_null()) { |
8faf50e0 XL |
346 | self.eat_char(); |
347 | buf.push(c as char); | |
348 | } | |
349 | Ok(()) | |
350 | } | |
351 | _ => { | |
352 | Err(self.error(ErrorCode::InvalidNumber)) | |
353 | } | |
354 | } | |
355 | } | |
356 | } | |
357 | ||
ff7c6d11 XL |
358 | #[cold] |
359 | fn fix_position(&self, err: Error) -> Error { | |
360 | err.fix_position(move |code| self.error(code)) | |
361 | } | |
362 | ||
7cac9316 | 363 | fn parse_ident(&mut self, ident: &[u8]) -> Result<()> { |
8faf50e0 | 364 | for expected in ident { |
f035d41b | 365 | match tri!(self.next_char()) { |
8faf50e0 XL |
366 | None => { |
367 | return Err(self.error(ErrorCode::EofWhileParsingValue)); | |
368 | } | |
369 | Some(next) => { | |
370 | if next != *expected { | |
371 | return Err(self.error(ErrorCode::ExpectedSomeIdent)); | |
372 | } | |
373 | } | |
7cac9316 XL |
374 | } |
375 | } | |
376 | ||
377 | Ok(()) | |
378 | } | |
379 | ||
8faf50e0 | 380 | fn parse_integer(&mut self, positive: bool) -> Result<ParserNumber> { |
f035d41b | 381 | let next = match tri!(self.next_char()) { |
416331ca XL |
382 | Some(b) => b, |
383 | None => { | |
384 | return Err(self.error(ErrorCode::EofWhileParsingValue)); | |
385 | } | |
386 | }; | |
387 | ||
388 | match next { | |
7cac9316 XL |
389 | b'0' => { |
390 | // There can be only one leading '0'. | |
f035d41b XL |
391 | match tri!(self.peek_or_null()) { |
392 | b'0'..=b'9' => Err(self.peek_error(ErrorCode::InvalidNumber)), | |
0531ce1d | 393 | _ => self.parse_number(positive, 0), |
7cac9316 XL |
394 | } |
395 | } | |
f035d41b XL |
396 | c @ b'1'..=b'9' => { |
397 | let mut significand = (c - b'0') as u64; | |
7cac9316 XL |
398 | |
399 | loop { | |
f035d41b XL |
400 | match tri!(self.peek_or_null()) { |
401 | c @ b'0'..=b'9' => { | |
7cac9316 XL |
402 | let digit = (c - b'0') as u64; |
403 | ||
f035d41b XL |
404 | // We need to be careful with overflow. If we can, |
405 | // try to keep the number as a `u64` until we grow | |
406 | // too large. At that point, switch to parsing the | |
407 | // value as a `f64`. | |
408 | if overflow!(significand * 10 + digit, u64::max_value()) { | |
409 | return Ok(ParserNumber::F64(tri!( | |
410 | self.parse_long_integer(positive, significand), | |
411 | ))); | |
7cac9316 XL |
412 | } |
413 | ||
f035d41b XL |
414 | self.eat_char(); |
415 | significand = significand * 10 + digit; | |
7cac9316 XL |
416 | } |
417 | _ => { | |
f035d41b | 418 | return self.parse_number(positive, significand); |
7cac9316 XL |
419 | } |
420 | } | |
421 | } | |
422 | } | |
423 | _ => Err(self.error(ErrorCode::InvalidNumber)), | |
424 | } | |
425 | } | |
426 | ||
8faf50e0 | 427 | fn parse_number(&mut self, positive: bool, significand: u64) -> Result<ParserNumber> { |
f035d41b XL |
428 | Ok(match tri!(self.peek_or_null()) { |
429 | b'.' => ParserNumber::F64(tri!(self.parse_decimal(positive, significand, 0))), | |
430 | b'e' | b'E' => ParserNumber::F64(tri!(self.parse_exponent(positive, significand, 0))), | |
7cac9316 | 431 | _ => { |
0531ce1d | 432 | if positive { |
8faf50e0 | 433 | ParserNumber::U64(significand) |
7cac9316 XL |
434 | } else { |
435 | let neg = (significand as i64).wrapping_neg(); | |
436 | ||
437 | // Convert into a float if we underflow. | |
438 | if neg > 0 { | |
8faf50e0 | 439 | ParserNumber::F64(-(significand as f64)) |
7cac9316 | 440 | } else { |
8faf50e0 | 441 | ParserNumber::I64(neg) |
7cac9316 XL |
442 | } |
443 | } | |
444 | } | |
041b39d2 | 445 | }) |
7cac9316 XL |
446 | } |
447 | ||
041b39d2 | 448 | fn parse_decimal( |
7cac9316 | 449 | &mut self, |
0531ce1d | 450 | positive: bool, |
7cac9316 XL |
451 | mut significand: u64, |
452 | mut exponent: i32, | |
041b39d2 | 453 | ) -> Result<f64> { |
7cac9316 XL |
454 | self.eat_char(); |
455 | ||
f035d41b | 456 | while let c @ b'0'..=b'9' = tri!(self.peek_or_null()) { |
7cac9316 | 457 | let digit = (c - b'0') as u64; |
7cac9316 | 458 | |
0531ce1d | 459 | if overflow!(significand * 10 + digit, u64::max_value()) { |
f035d41b | 460 | return self.parse_decimal_overflow(positive, significand, exponent); |
7cac9316 XL |
461 | } |
462 | ||
f035d41b | 463 | self.eat_char(); |
7cac9316 XL |
464 | significand = significand * 10 + digit; |
465 | exponent -= 1; | |
466 | } | |
467 | ||
f035d41b XL |
468 | // Error if there is not at least one digit after the decimal point. |
469 | if exponent == 0 { | |
470 | match tri!(self.peek()) { | |
416331ca XL |
471 | Some(_) => return Err(self.peek_error(ErrorCode::InvalidNumber)), |
472 | None => return Err(self.peek_error(ErrorCode::EofWhileParsingValue)), | |
473 | } | |
7cac9316 XL |
474 | } |
475 | ||
f035d41b | 476 | match tri!(self.peek_or_null()) { |
0531ce1d XL |
477 | b'e' | b'E' => self.parse_exponent(positive, significand, exponent), |
478 | _ => self.f64_from_parts(positive, significand, exponent), | |
7cac9316 XL |
479 | } |
480 | } | |
481 | ||
041b39d2 | 482 | fn parse_exponent( |
7cac9316 | 483 | &mut self, |
0531ce1d | 484 | positive: bool, |
7cac9316 XL |
485 | significand: u64, |
486 | starting_exp: i32, | |
041b39d2 | 487 | ) -> Result<f64> { |
7cac9316 XL |
488 | self.eat_char(); |
489 | ||
f035d41b | 490 | let positive_exp = match tri!(self.peek_or_null()) { |
7cac9316 XL |
491 | b'+' => { |
492 | self.eat_char(); | |
493 | true | |
494 | } | |
495 | b'-' => { | |
496 | self.eat_char(); | |
497 | false | |
498 | } | |
499 | _ => true, | |
500 | }; | |
501 | ||
f035d41b | 502 | let next = match tri!(self.next_char()) { |
416331ca XL |
503 | Some(b) => b, |
504 | None => { | |
505 | return Err(self.error(ErrorCode::EofWhileParsingValue)); | |
506 | } | |
507 | }; | |
508 | ||
7cac9316 | 509 | // Make sure a digit follows the exponent place. |
416331ca | 510 | let mut exp = match next { |
f035d41b | 511 | c @ b'0'..=b'9' => (c - b'0') as i32, |
7cac9316 XL |
512 | _ => { |
513 | return Err(self.error(ErrorCode::InvalidNumber)); | |
514 | } | |
515 | }; | |
516 | ||
f035d41b | 517 | while let c @ b'0'..=b'9' = tri!(self.peek_or_null()) { |
7cac9316 XL |
518 | self.eat_char(); |
519 | let digit = (c - b'0') as i32; | |
520 | ||
0531ce1d | 521 | if overflow!(exp * 10 + digit, i32::max_value()) { |
f035d41b XL |
522 | let zero_significand = significand == 0; |
523 | return self.parse_exponent_overflow(positive, zero_significand, positive_exp); | |
7cac9316 XL |
524 | } |
525 | ||
526 | exp = exp * 10 + digit; | |
527 | } | |
528 | ||
83c7162d | 529 | let final_exp = if positive_exp { |
7cac9316 XL |
530 | starting_exp.saturating_add(exp) |
531 | } else { | |
532 | starting_exp.saturating_sub(exp) | |
533 | }; | |
534 | ||
0531ce1d | 535 | self.f64_from_parts(positive, significand, final_exp) |
7cac9316 XL |
536 | } |
537 | ||
f035d41b XL |
538 | #[cfg(feature = "float_roundtrip")] |
539 | fn f64_from_parts(&mut self, positive: bool, significand: u64, exponent: i32) -> Result<f64> { | |
540 | let f = if self.single_precision { | |
541 | lexical::parse_concise_float::<f32>(significand, exponent) as f64 | |
542 | } else { | |
543 | lexical::parse_concise_float::<f64>(significand, exponent) | |
544 | }; | |
545 | ||
546 | if f.is_infinite() { | |
547 | Err(self.error(ErrorCode::NumberOutOfRange)) | |
548 | } else { | |
549 | Ok(if positive { f } else { -f }) | |
550 | } | |
551 | } | |
552 | ||
553 | #[cfg(not(feature = "float_roundtrip"))] | |
554 | fn f64_from_parts( | |
555 | &mut self, | |
556 | positive: bool, | |
557 | significand: u64, | |
558 | mut exponent: i32, | |
559 | ) -> Result<f64> { | |
560 | let mut f = significand as f64; | |
561 | loop { | |
562 | match POW10.get(exponent.wrapping_abs() as usize) { | |
563 | Some(&pow) => { | |
564 | if exponent >= 0 { | |
565 | f *= pow; | |
566 | if f.is_infinite() { | |
567 | return Err(self.error(ErrorCode::NumberOutOfRange)); | |
568 | } | |
569 | } else { | |
570 | f /= pow; | |
571 | } | |
572 | break; | |
573 | } | |
574 | None => { | |
575 | if f == 0.0 { | |
576 | break; | |
577 | } | |
578 | if exponent >= 0 { | |
579 | return Err(self.error(ErrorCode::NumberOutOfRange)); | |
580 | } | |
581 | f /= 1e308; | |
582 | exponent += 308; | |
583 | } | |
584 | } | |
585 | } | |
586 | Ok(if positive { f } else { -f }) | |
587 | } | |
588 | ||
589 | #[cfg(feature = "float_roundtrip")] | |
590 | #[cold] | |
591 | #[inline(never)] | |
592 | fn parse_long_integer(&mut self, positive: bool, partial_significand: u64) -> Result<f64> { | |
593 | // To deserialize floats we'll first push the integer and fraction | |
594 | // parts, both as byte strings, into the scratch buffer and then feed | |
595 | // both slices to lexical's parser. For example if the input is | |
596 | // `12.34e5` we'll push b"1234" into scratch and then pass b"12" and | |
597 | // b"34" to lexical. `integer_end` will be used to track where to split | |
598 | // the scratch buffer. | |
599 | // | |
600 | // Note that lexical expects the integer part to contain *no* leading | |
601 | // zeroes and the fraction part to contain *no* trailing zeroes. The | |
602 | // first requirement is already handled by the integer parsing logic. | |
603 | // The second requirement will be enforced just before passing the | |
604 | // slices to lexical in f64_long_from_parts. | |
605 | self.scratch.clear(); | |
606 | self.scratch | |
607 | .extend_from_slice(itoa::Buffer::new().format(partial_significand).as_bytes()); | |
608 | ||
609 | loop { | |
610 | match tri!(self.peek_or_null()) { | |
611 | c @ b'0'..=b'9' => { | |
612 | self.scratch.push(c); | |
613 | self.eat_char(); | |
614 | } | |
615 | b'.' => { | |
616 | self.eat_char(); | |
617 | return self.parse_long_decimal(positive, self.scratch.len()); | |
618 | } | |
619 | b'e' | b'E' => { | |
620 | return self.parse_long_exponent(positive, self.scratch.len()); | |
621 | } | |
622 | _ => { | |
623 | return self.f64_long_from_parts(positive, self.scratch.len(), 0); | |
624 | } | |
625 | } | |
626 | } | |
627 | } | |
628 | ||
629 | #[cfg(not(feature = "float_roundtrip"))] | |
630 | #[cold] | |
631 | #[inline(never)] | |
632 | fn parse_long_integer(&mut self, positive: bool, significand: u64) -> Result<f64> { | |
633 | let mut exponent = 0; | |
634 | loop { | |
635 | match tri!(self.peek_or_null()) { | |
636 | b'0'..=b'9' => { | |
637 | self.eat_char(); | |
638 | // This could overflow... if your integer is gigabytes long. | |
639 | // Ignore that possibility. | |
640 | exponent += 1; | |
641 | } | |
642 | b'.' => { | |
643 | return self.parse_decimal(positive, significand, exponent); | |
644 | } | |
645 | b'e' | b'E' => { | |
646 | return self.parse_exponent(positive, significand, exponent); | |
647 | } | |
648 | _ => { | |
649 | return self.f64_from_parts(positive, significand, exponent); | |
650 | } | |
651 | } | |
652 | } | |
653 | } | |
654 | ||
655 | #[cfg(feature = "float_roundtrip")] | |
656 | #[cold] | |
657 | fn parse_long_decimal(&mut self, positive: bool, integer_end: usize) -> Result<f64> { | |
658 | let mut at_least_one_digit = integer_end < self.scratch.len(); | |
659 | while let c @ b'0'..=b'9' = tri!(self.peek_or_null()) { | |
660 | self.scratch.push(c); | |
661 | self.eat_char(); | |
662 | at_least_one_digit = true; | |
663 | } | |
664 | ||
665 | if !at_least_one_digit { | |
666 | match tri!(self.peek()) { | |
667 | Some(_) => return Err(self.peek_error(ErrorCode::InvalidNumber)), | |
668 | None => return Err(self.peek_error(ErrorCode::EofWhileParsingValue)), | |
669 | } | |
670 | } | |
671 | ||
672 | match tri!(self.peek_or_null()) { | |
673 | b'e' | b'E' => self.parse_long_exponent(positive, integer_end), | |
674 | _ => self.f64_long_from_parts(positive, integer_end, 0), | |
675 | } | |
676 | } | |
677 | ||
678 | #[cfg(feature = "float_roundtrip")] | |
679 | fn parse_long_exponent(&mut self, positive: bool, integer_end: usize) -> Result<f64> { | |
680 | self.eat_char(); | |
681 | ||
682 | let positive_exp = match tri!(self.peek_or_null()) { | |
683 | b'+' => { | |
684 | self.eat_char(); | |
685 | true | |
686 | } | |
687 | b'-' => { | |
688 | self.eat_char(); | |
689 | false | |
690 | } | |
691 | _ => true, | |
692 | }; | |
693 | ||
694 | let next = match tri!(self.next_char()) { | |
695 | Some(b) => b, | |
696 | None => { | |
697 | return Err(self.error(ErrorCode::EofWhileParsingValue)); | |
698 | } | |
699 | }; | |
700 | ||
701 | // Make sure a digit follows the exponent place. | |
702 | let mut exp = match next { | |
703 | c @ b'0'..=b'9' => (c - b'0') as i32, | |
704 | _ => { | |
705 | return Err(self.error(ErrorCode::InvalidNumber)); | |
706 | } | |
707 | }; | |
708 | ||
709 | while let c @ b'0'..=b'9' = tri!(self.peek_or_null()) { | |
710 | self.eat_char(); | |
711 | let digit = (c - b'0') as i32; | |
712 | ||
713 | if overflow!(exp * 10 + digit, i32::max_value()) { | |
714 | let zero_significand = self.scratch.iter().all(|&digit| digit == b'0'); | |
715 | return self.parse_exponent_overflow(positive, zero_significand, positive_exp); | |
716 | } | |
717 | ||
718 | exp = exp * 10 + digit; | |
719 | } | |
720 | ||
721 | let final_exp = if positive_exp { exp } else { -exp }; | |
722 | ||
723 | self.f64_long_from_parts(positive, integer_end, final_exp) | |
724 | } | |
725 | ||
726 | // This cold code should not be inlined into the middle of the hot | |
727 | // decimal-parsing loop above. | |
728 | #[cfg(feature = "float_roundtrip")] | |
729 | #[cold] | |
730 | #[inline(never)] | |
731 | fn parse_decimal_overflow( | |
732 | &mut self, | |
733 | positive: bool, | |
734 | significand: u64, | |
735 | exponent: i32, | |
736 | ) -> Result<f64> { | |
737 | let mut buffer = itoa::Buffer::new(); | |
738 | let significand = buffer.format(significand); | |
739 | let fraction_digits = -exponent as usize; | |
740 | self.scratch.clear(); | |
741 | if let Some(zeros) = fraction_digits.checked_sub(significand.len() + 1) { | |
742 | self.scratch.extend(iter::repeat(b'0').take(zeros + 1)); | |
743 | } | |
744 | self.scratch.extend_from_slice(significand.as_bytes()); | |
745 | let integer_end = self.scratch.len() - fraction_digits; | |
746 | self.parse_long_decimal(positive, integer_end) | |
747 | } | |
748 | ||
749 | #[cfg(not(feature = "float_roundtrip"))] | |
750 | #[cold] | |
751 | #[inline(never)] | |
752 | fn parse_decimal_overflow( | |
753 | &mut self, | |
754 | positive: bool, | |
755 | significand: u64, | |
756 | exponent: i32, | |
757 | ) -> Result<f64> { | |
758 | // The next multiply/add would overflow, so just ignore all further | |
759 | // digits. | |
760 | while let b'0'..=b'9' = tri!(self.peek_or_null()) { | |
761 | self.eat_char(); | |
762 | } | |
763 | ||
764 | match tri!(self.peek_or_null()) { | |
765 | b'e' | b'E' => self.parse_exponent(positive, significand, exponent), | |
766 | _ => self.f64_from_parts(positive, significand, exponent), | |
767 | } | |
768 | } | |
769 | ||
7cac9316 XL |
770 | // This cold code should not be inlined into the middle of the hot |
771 | // exponent-parsing loop above. | |
772 | #[cold] | |
773 | #[inline(never)] | |
041b39d2 | 774 | fn parse_exponent_overflow( |
7cac9316 | 775 | &mut self, |
0531ce1d | 776 | positive: bool, |
f035d41b | 777 | zero_significand: bool, |
83c7162d | 778 | positive_exp: bool, |
041b39d2 | 779 | ) -> Result<f64> { |
7cac9316 | 780 | // Error instead of +/- infinity. |
f035d41b | 781 | if !zero_significand && positive_exp { |
7cac9316 XL |
782 | return Err(self.error(ErrorCode::NumberOutOfRange)); |
783 | } | |
784 | ||
f035d41b | 785 | while let b'0'..=b'9' = tri!(self.peek_or_null()) { |
7cac9316 XL |
786 | self.eat_char(); |
787 | } | |
0531ce1d XL |
788 | Ok(if positive { 0.0 } else { -0.0 }) |
789 | } | |
790 | ||
f035d41b XL |
791 | #[cfg(feature = "float_roundtrip")] |
792 | fn f64_long_from_parts( | |
793 | &mut self, | |
794 | positive: bool, | |
795 | integer_end: usize, | |
796 | exponent: i32, | |
797 | ) -> Result<f64> { | |
798 | let integer = &self.scratch[..integer_end]; | |
799 | let fraction = &self.scratch[integer_end..]; | |
800 | ||
801 | let f = if self.single_precision { | |
802 | lexical::parse_truncated_float::<f32>(integer, fraction, exponent) as f64 | |
803 | } else { | |
804 | lexical::parse_truncated_float::<f64>(integer, fraction, exponent) | |
805 | }; | |
806 | ||
807 | if f.is_infinite() { | |
808 | Err(self.error(ErrorCode::NumberOutOfRange)) | |
809 | } else { | |
810 | Ok(if positive { f } else { -f }) | |
811 | } | |
812 | } | |
813 | ||
8faf50e0 | 814 | fn parse_any_signed_number(&mut self) -> Result<ParserNumber> { |
f035d41b | 815 | let peek = match tri!(self.peek()) { |
0531ce1d XL |
816 | Some(b) => b, |
817 | None => { | |
818 | return Err(self.peek_error(ErrorCode::EofWhileParsingValue)); | |
819 | } | |
820 | }; | |
821 | ||
822 | let value = match peek { | |
823 | b'-' => { | |
824 | self.eat_char(); | |
825 | self.parse_any_number(false) | |
826 | } | |
f035d41b | 827 | b'0'..=b'9' => self.parse_any_number(true), |
0531ce1d XL |
828 | _ => Err(self.peek_error(ErrorCode::InvalidNumber)), |
829 | }; | |
830 | ||
f035d41b | 831 | let value = match tri!(self.peek()) { |
0531ce1d XL |
832 | Some(_) => Err(self.peek_error(ErrorCode::InvalidNumber)), |
833 | None => value, | |
834 | }; | |
835 | ||
836 | match value { | |
837 | Ok(value) => Ok(value), | |
838 | // The de::Error impl creates errors with unknown line and column. | |
839 | // Fill in the position here by looking at the current index in the | |
840 | // input. There is no way to tell whether this should call `error` | |
841 | // or `peek_error` so pick the one that seems correct more often. | |
842 | // Worst case, the position is off by one character. | |
843 | Err(err) => Err(self.fix_position(err)), | |
844 | } | |
845 | } | |
846 | ||
847 | #[cfg(not(feature = "arbitrary_precision"))] | |
8faf50e0 | 848 | fn parse_any_number(&mut self, positive: bool) -> Result<ParserNumber> { |
83c7162d | 849 | self.parse_integer(positive) |
0531ce1d XL |
850 | } |
851 | ||
852 | #[cfg(feature = "arbitrary_precision")] | |
8faf50e0 | 853 | fn parse_any_number(&mut self, positive: bool) -> Result<ParserNumber> { |
0531ce1d | 854 | let mut buf = String::with_capacity(16); |
83c7162d | 855 | if !positive { |
0531ce1d XL |
856 | buf.push('-'); |
857 | } | |
858 | self.scan_integer(&mut buf)?; | |
8faf50e0 | 859 | Ok(ParserNumber::String(buf)) |
0531ce1d XL |
860 | } |
861 | ||
862 | #[cfg(feature = "arbitrary_precision")] | |
416331ca | 863 | fn scan_or_eof(&mut self, buf: &mut String) -> Result<u8> { |
f035d41b | 864 | match tri!(self.next_char()) { |
0531ce1d XL |
865 | Some(b) => { |
866 | buf.push(b as char); | |
867 | Ok(b) | |
868 | } | |
f035d41b | 869 | None => Err(self.error(ErrorCode::EofWhileParsingValue)), |
0531ce1d XL |
870 | } |
871 | } | |
872 | ||
873 | #[cfg(feature = "arbitrary_precision")] | |
874 | fn scan_integer(&mut self, buf: &mut String) -> Result<()> { | |
f035d41b | 875 | match tri!(self.scan_or_eof(buf)) { |
0531ce1d XL |
876 | b'0' => { |
877 | // There can be only one leading '0'. | |
f035d41b XL |
878 | match tri!(self.peek_or_null()) { |
879 | b'0'..=b'9' => Err(self.peek_error(ErrorCode::InvalidNumber)), | |
0531ce1d XL |
880 | _ => self.scan_number(buf), |
881 | } | |
882 | } | |
f035d41b XL |
883 | b'1'..=b'9' => loop { |
884 | match tri!(self.peek_or_null()) { | |
885 | c @ b'0'..=b'9' => { | |
83c7162d XL |
886 | self.eat_char(); |
887 | buf.push(c as char); | |
888 | } | |
889 | _ => { | |
890 | return self.scan_number(buf); | |
0531ce1d XL |
891 | } |
892 | } | |
83c7162d | 893 | }, |
0531ce1d XL |
894 | _ => Err(self.error(ErrorCode::InvalidNumber)), |
895 | } | |
896 | } | |
897 | ||
898 | #[cfg(feature = "arbitrary_precision")] | |
899 | fn scan_number(&mut self, buf: &mut String) -> Result<()> { | |
f035d41b | 900 | match tri!(self.peek_or_null()) { |
0531ce1d | 901 | b'.' => self.scan_decimal(buf), |
94222f64 | 902 | e @ b'e' | e @ b'E' => self.scan_exponent(e as char, buf), |
0531ce1d XL |
903 | _ => Ok(()), |
904 | } | |
905 | } | |
906 | ||
907 | #[cfg(feature = "arbitrary_precision")] | |
908 | fn scan_decimal(&mut self, buf: &mut String) -> Result<()> { | |
909 | self.eat_char(); | |
910 | buf.push('.'); | |
911 | ||
912 | let mut at_least_one_digit = false; | |
f035d41b | 913 | while let c @ b'0'..=b'9' = tri!(self.peek_or_null()) { |
0531ce1d XL |
914 | self.eat_char(); |
915 | buf.push(c as char); | |
916 | at_least_one_digit = true; | |
917 | } | |
918 | ||
919 | if !at_least_one_digit { | |
f035d41b | 920 | match tri!(self.peek()) { |
416331ca XL |
921 | Some(_) => return Err(self.peek_error(ErrorCode::InvalidNumber)), |
922 | None => return Err(self.peek_error(ErrorCode::EofWhileParsingValue)), | |
923 | } | |
0531ce1d XL |
924 | } |
925 | ||
f035d41b | 926 | match tri!(self.peek_or_null()) { |
94222f64 | 927 | e @ b'e' | e @ b'E' => self.scan_exponent(e as char, buf), |
0531ce1d XL |
928 | _ => Ok(()), |
929 | } | |
930 | } | |
931 | ||
932 | #[cfg(feature = "arbitrary_precision")] | |
94222f64 | 933 | fn scan_exponent(&mut self, e: char, buf: &mut String) -> Result<()> { |
0531ce1d | 934 | self.eat_char(); |
94222f64 | 935 | buf.push(e); |
0531ce1d | 936 | |
f035d41b | 937 | match tri!(self.peek_or_null()) { |
0531ce1d XL |
938 | b'+' => { |
939 | self.eat_char(); | |
94222f64 | 940 | buf.push('+'); |
0531ce1d XL |
941 | } |
942 | b'-' => { | |
943 | self.eat_char(); | |
944 | buf.push('-'); | |
945 | } | |
946 | _ => {} | |
947 | } | |
948 | ||
949 | // Make sure a digit follows the exponent place. | |
f035d41b XL |
950 | match tri!(self.scan_or_eof(buf)) { |
951 | b'0'..=b'9' => {} | |
0531ce1d XL |
952 | _ => { |
953 | return Err(self.error(ErrorCode::InvalidNumber)); | |
954 | } | |
955 | } | |
956 | ||
f035d41b | 957 | while let c @ b'0'..=b'9' = tri!(self.peek_or_null()) { |
0531ce1d XL |
958 | self.eat_char(); |
959 | buf.push(c as char); | |
960 | } | |
961 | ||
962 | Ok(()) | |
7cac9316 XL |
963 | } |
964 | ||
7cac9316 | 965 | fn parse_object_colon(&mut self) -> Result<()> { |
f035d41b | 966 | match tri!(self.parse_whitespace()) { |
7cac9316 XL |
967 | Some(b':') => { |
968 | self.eat_char(); | |
969 | Ok(()) | |
970 | } | |
971 | Some(_) => Err(self.peek_error(ErrorCode::ExpectedColon)), | |
972 | None => Err(self.peek_error(ErrorCode::EofWhileParsingObject)), | |
973 | } | |
974 | } | |
975 | ||
976 | fn end_seq(&mut self) -> Result<()> { | |
f035d41b | 977 | match tri!(self.parse_whitespace()) { |
041b39d2 XL |
978 | Some(b']') => { |
979 | self.eat_char(); | |
980 | Ok(()) | |
981 | } | |
abe05a73 XL |
982 | Some(b',') => { |
983 | self.eat_char(); | |
984 | match self.parse_whitespace() { | |
985 | Ok(Some(b']')) => Err(self.peek_error(ErrorCode::TrailingComma)), | |
986 | _ => Err(self.peek_error(ErrorCode::TrailingCharacters)), | |
987 | } | |
988 | } | |
041b39d2 XL |
989 | Some(_) => Err(self.peek_error(ErrorCode::TrailingCharacters)), |
990 | None => Err(self.peek_error(ErrorCode::EofWhileParsingList)), | |
7cac9316 XL |
991 | } |
992 | } | |
993 | ||
994 | fn end_map(&mut self) -> Result<()> { | |
f035d41b | 995 | match tri!(self.parse_whitespace()) { |
041b39d2 XL |
996 | Some(b'}') => { |
997 | self.eat_char(); | |
998 | Ok(()) | |
999 | } | |
abe05a73 | 1000 | Some(b',') => Err(self.peek_error(ErrorCode::TrailingComma)), |
041b39d2 XL |
1001 | Some(_) => Err(self.peek_error(ErrorCode::TrailingCharacters)), |
1002 | None => Err(self.peek_error(ErrorCode::EofWhileParsingObject)), | |
7cac9316 XL |
1003 | } |
1004 | } | |
ea8adc8c XL |
1005 | |
1006 | fn ignore_value(&mut self) -> Result<()> { | |
0bf4aa26 XL |
1007 | self.scratch.clear(); |
1008 | let mut enclosing = None; | |
ea8adc8c | 1009 | |
0bf4aa26 | 1010 | loop { |
f035d41b | 1011 | let peek = match tri!(self.parse_whitespace()) { |
0bf4aa26 XL |
1012 | Some(b) => b, |
1013 | None => { | |
1014 | return Err(self.peek_error(ErrorCode::EofWhileParsingValue)); | |
ea8adc8c | 1015 | } |
0bf4aa26 | 1016 | }; |
ea8adc8c | 1017 | |
0bf4aa26 XL |
1018 | let frame = match peek { |
1019 | b'n' => { | |
1020 | self.eat_char(); | |
f035d41b | 1021 | tri!(self.parse_ident(b"ull")); |
0bf4aa26 XL |
1022 | None |
1023 | } | |
1024 | b't' => { | |
1025 | self.eat_char(); | |
f035d41b | 1026 | tri!(self.parse_ident(b"rue")); |
0bf4aa26 XL |
1027 | None |
1028 | } | |
1029 | b'f' => { | |
1030 | self.eat_char(); | |
f035d41b | 1031 | tri!(self.parse_ident(b"alse")); |
0bf4aa26 XL |
1032 | None |
1033 | } | |
1034 | b'-' => { | |
1035 | self.eat_char(); | |
f035d41b | 1036 | tri!(self.ignore_integer()); |
0bf4aa26 XL |
1037 | None |
1038 | } | |
f035d41b XL |
1039 | b'0'..=b'9' => { |
1040 | tri!(self.ignore_integer()); | |
0bf4aa26 XL |
1041 | None |
1042 | } | |
1043 | b'"' => { | |
1044 | self.eat_char(); | |
f035d41b | 1045 | tri!(self.read.ignore_str()); |
0bf4aa26 XL |
1046 | None |
1047 | } | |
1048 | frame @ b'[' | frame @ b'{' => { | |
1049 | self.scratch.extend(enclosing.take()); | |
1050 | self.eat_char(); | |
1051 | Some(frame) | |
1052 | } | |
1053 | _ => return Err(self.peek_error(ErrorCode::ExpectedSomeValue)), | |
1054 | }; | |
1055 | ||
1056 | let (mut accept_comma, mut frame) = match frame { | |
1057 | Some(frame) => (false, frame), | |
1058 | None => match enclosing.take() { | |
1059 | Some(frame) => (true, frame), | |
1060 | None => match self.scratch.pop() { | |
1061 | Some(frame) => (true, frame), | |
1062 | None => return Ok(()), | |
1063 | }, | |
1064 | }, | |
1065 | }; | |
1066 | ||
1067 | loop { | |
f035d41b | 1068 | match tri!(self.parse_whitespace()) { |
0bf4aa26 XL |
1069 | Some(b',') if accept_comma => { |
1070 | self.eat_char(); | |
1071 | break; | |
1072 | } | |
1073 | Some(b']') if frame == b'[' => {} | |
1074 | Some(b'}') if frame == b'{' => {} | |
1075 | Some(_) => { | |
1076 | if accept_comma { | |
1077 | return Err(self.peek_error(match frame { | |
1078 | b'[' => ErrorCode::ExpectedListCommaOrEnd, | |
1079 | b'{' => ErrorCode::ExpectedObjectCommaOrEnd, | |
1080 | _ => unreachable!(), | |
1081 | })); | |
1082 | } else { | |
1083 | break; | |
1084 | } | |
1085 | } | |
1086 | None => { | |
1087 | return Err(self.peek_error(match frame { | |
1088 | b'[' => ErrorCode::EofWhileParsingList, | |
1089 | b'{' => ErrorCode::EofWhileParsingObject, | |
1090 | _ => unreachable!(), | |
1091 | })); | |
1092 | } | |
ea8adc8c XL |
1093 | } |
1094 | ||
1095 | self.eat_char(); | |
0bf4aa26 XL |
1096 | frame = match self.scratch.pop() { |
1097 | Some(frame) => frame, | |
1098 | None => return Ok(()), | |
1099 | }; | |
1100 | accept_comma = true; | |
ea8adc8c | 1101 | } |
0bf4aa26 XL |
1102 | |
1103 | if frame == b'{' { | |
f035d41b | 1104 | match tri!(self.parse_whitespace()) { |
0bf4aa26 XL |
1105 | Some(b'"') => self.eat_char(), |
1106 | Some(_) => return Err(self.peek_error(ErrorCode::KeyMustBeAString)), | |
1107 | None => return Err(self.peek_error(ErrorCode::EofWhileParsingObject)), | |
1108 | } | |
f035d41b XL |
1109 | tri!(self.read.ignore_str()); |
1110 | match tri!(self.parse_whitespace()) { | |
0bf4aa26 XL |
1111 | Some(b':') => self.eat_char(), |
1112 | Some(_) => return Err(self.peek_error(ErrorCode::ExpectedColon)), | |
1113 | None => return Err(self.peek_error(ErrorCode::EofWhileParsingObject)), | |
1114 | } | |
1115 | } | |
1116 | ||
1117 | enclosing = Some(frame); | |
ea8adc8c XL |
1118 | } |
1119 | } | |
1120 | ||
1121 | fn ignore_integer(&mut self) -> Result<()> { | |
f035d41b | 1122 | match tri!(self.next_char_or_null()) { |
ea8adc8c XL |
1123 | b'0' => { |
1124 | // There can be only one leading '0'. | |
f035d41b | 1125 | if let b'0'..=b'9' = tri!(self.peek_or_null()) { |
ea8adc8c XL |
1126 | return Err(self.peek_error(ErrorCode::InvalidNumber)); |
1127 | } | |
1128 | } | |
f035d41b XL |
1129 | b'1'..=b'9' => { |
1130 | while let b'0'..=b'9' = tri!(self.peek_or_null()) { | |
0731742a XL |
1131 | self.eat_char(); |
1132 | } | |
1133 | } | |
ea8adc8c XL |
1134 | _ => { |
1135 | return Err(self.error(ErrorCode::InvalidNumber)); | |
1136 | } | |
1137 | } | |
1138 | ||
f035d41b | 1139 | match tri!(self.peek_or_null()) { |
ea8adc8c XL |
1140 | b'.' => self.ignore_decimal(), |
1141 | b'e' | b'E' => self.ignore_exponent(), | |
1142 | _ => Ok(()), | |
1143 | } | |
1144 | } | |
1145 | ||
1146 | fn ignore_decimal(&mut self) -> Result<()> { | |
1147 | self.eat_char(); | |
1148 | ||
1149 | let mut at_least_one_digit = false; | |
f035d41b | 1150 | while let b'0'..=b'9' = tri!(self.peek_or_null()) { |
ea8adc8c XL |
1151 | self.eat_char(); |
1152 | at_least_one_digit = true; | |
1153 | } | |
1154 | ||
1155 | if !at_least_one_digit { | |
1156 | return Err(self.peek_error(ErrorCode::InvalidNumber)); | |
1157 | } | |
1158 | ||
f035d41b | 1159 | match tri!(self.peek_or_null()) { |
ea8adc8c XL |
1160 | b'e' | b'E' => self.ignore_exponent(), |
1161 | _ => Ok(()), | |
1162 | } | |
1163 | } | |
1164 | ||
1165 | fn ignore_exponent(&mut self) -> Result<()> { | |
1166 | self.eat_char(); | |
1167 | ||
f035d41b | 1168 | match tri!(self.peek_or_null()) { |
ea8adc8c XL |
1169 | b'+' | b'-' => self.eat_char(), |
1170 | _ => {} | |
1171 | } | |
1172 | ||
1173 | // Make sure a digit follows the exponent place. | |
f035d41b XL |
1174 | match tri!(self.next_char_or_null()) { |
1175 | b'0'..=b'9' => {} | |
ea8adc8c XL |
1176 | _ => { |
1177 | return Err(self.error(ErrorCode::InvalidNumber)); | |
1178 | } | |
1179 | } | |
1180 | ||
f035d41b | 1181 | while let b'0'..=b'9' = tri!(self.peek_or_null()) { |
ea8adc8c XL |
1182 | self.eat_char(); |
1183 | } | |
1184 | ||
1185 | Ok(()) | |
1186 | } | |
1187 | ||
0bf4aa26 XL |
1188 | #[cfg(feature = "raw_value")] |
1189 | fn deserialize_raw_value<V>(&mut self, visitor: V) -> Result<V::Value> | |
1190 | where | |
1191 | V: de::Visitor<'de>, | |
1192 | { | |
1193 | self.parse_whitespace()?; | |
1194 | self.read.begin_raw_buffering(); | |
1195 | self.ignore_value()?; | |
1196 | self.read.end_raw_buffering(visitor) | |
ea8adc8c | 1197 | } |
7cac9316 XL |
1198 | } |
1199 | ||
8faf50e0 XL |
1200 | impl FromStr for Number { |
1201 | type Err = Error; | |
1202 | ||
1203 | fn from_str(s: &str) -> result::Result<Self, Self::Err> { | |
1204 | Deserializer::from_str(s) | |
1205 | .parse_any_signed_number() | |
1206 | .map(Into::into) | |
1207 | } | |
1208 | } | |
1209 | ||
f035d41b | 1210 | #[cfg(not(feature = "float_roundtrip"))] |
416331ca XL |
1211 | static POW10: [f64; 309] = [ |
1212 | 1e000, 1e001, 1e002, 1e003, 1e004, 1e005, 1e006, 1e007, 1e008, 1e009, // | |
1213 | 1e010, 1e011, 1e012, 1e013, 1e014, 1e015, 1e016, 1e017, 1e018, 1e019, // | |
1214 | 1e020, 1e021, 1e022, 1e023, 1e024, 1e025, 1e026, 1e027, 1e028, 1e029, // | |
1215 | 1e030, 1e031, 1e032, 1e033, 1e034, 1e035, 1e036, 1e037, 1e038, 1e039, // | |
1216 | 1e040, 1e041, 1e042, 1e043, 1e044, 1e045, 1e046, 1e047, 1e048, 1e049, // | |
1217 | 1e050, 1e051, 1e052, 1e053, 1e054, 1e055, 1e056, 1e057, 1e058, 1e059, // | |
1218 | 1e060, 1e061, 1e062, 1e063, 1e064, 1e065, 1e066, 1e067, 1e068, 1e069, // | |
1219 | 1e070, 1e071, 1e072, 1e073, 1e074, 1e075, 1e076, 1e077, 1e078, 1e079, // | |
1220 | 1e080, 1e081, 1e082, 1e083, 1e084, 1e085, 1e086, 1e087, 1e088, 1e089, // | |
1221 | 1e090, 1e091, 1e092, 1e093, 1e094, 1e095, 1e096, 1e097, 1e098, 1e099, // | |
1222 | 1e100, 1e101, 1e102, 1e103, 1e104, 1e105, 1e106, 1e107, 1e108, 1e109, // | |
1223 | 1e110, 1e111, 1e112, 1e113, 1e114, 1e115, 1e116, 1e117, 1e118, 1e119, // | |
1224 | 1e120, 1e121, 1e122, 1e123, 1e124, 1e125, 1e126, 1e127, 1e128, 1e129, // | |
1225 | 1e130, 1e131, 1e132, 1e133, 1e134, 1e135, 1e136, 1e137, 1e138, 1e139, // | |
1226 | 1e140, 1e141, 1e142, 1e143, 1e144, 1e145, 1e146, 1e147, 1e148, 1e149, // | |
1227 | 1e150, 1e151, 1e152, 1e153, 1e154, 1e155, 1e156, 1e157, 1e158, 1e159, // | |
1228 | 1e160, 1e161, 1e162, 1e163, 1e164, 1e165, 1e166, 1e167, 1e168, 1e169, // | |
1229 | 1e170, 1e171, 1e172, 1e173, 1e174, 1e175, 1e176, 1e177, 1e178, 1e179, // | |
1230 | 1e180, 1e181, 1e182, 1e183, 1e184, 1e185, 1e186, 1e187, 1e188, 1e189, // | |
1231 | 1e190, 1e191, 1e192, 1e193, 1e194, 1e195, 1e196, 1e197, 1e198, 1e199, // | |
1232 | 1e200, 1e201, 1e202, 1e203, 1e204, 1e205, 1e206, 1e207, 1e208, 1e209, // | |
1233 | 1e210, 1e211, 1e212, 1e213, 1e214, 1e215, 1e216, 1e217, 1e218, 1e219, // | |
1234 | 1e220, 1e221, 1e222, 1e223, 1e224, 1e225, 1e226, 1e227, 1e228, 1e229, // | |
1235 | 1e230, 1e231, 1e232, 1e233, 1e234, 1e235, 1e236, 1e237, 1e238, 1e239, // | |
1236 | 1e240, 1e241, 1e242, 1e243, 1e244, 1e245, 1e246, 1e247, 1e248, 1e249, // | |
1237 | 1e250, 1e251, 1e252, 1e253, 1e254, 1e255, 1e256, 1e257, 1e258, 1e259, // | |
1238 | 1e260, 1e261, 1e262, 1e263, 1e264, 1e265, 1e266, 1e267, 1e268, 1e269, // | |
1239 | 1e270, 1e271, 1e272, 1e273, 1e274, 1e275, 1e276, 1e277, 1e278, 1e279, // | |
1240 | 1e280, 1e281, 1e282, 1e283, 1e284, 1e285, 1e286, 1e287, 1e288, 1e289, // | |
1241 | 1e290, 1e291, 1e292, 1e293, 1e294, 1e295, 1e296, 1e297, 1e298, 1e299, // | |
1242 | 1e300, 1e301, 1e302, 1e303, 1e304, 1e305, 1e306, 1e307, 1e308, | |
1243 | ]; | |
7cac9316 | 1244 | |
f035d41b | 1245 | macro_rules! deserialize_number { |
0531ce1d XL |
1246 | ($method:ident) => { |
1247 | fn $method<V>(self, visitor: V) -> Result<V::Value> | |
1248 | where | |
1249 | V: de::Visitor<'de>, | |
1250 | { | |
f035d41b | 1251 | self.deserialize_number(visitor) |
0531ce1d | 1252 | } |
f035d41b | 1253 | }; |
0531ce1d XL |
1254 | } |
1255 | ||
416331ca XL |
1256 | #[cfg(not(feature = "unbounded_depth"))] |
1257 | macro_rules! if_checking_recursion_limit { | |
1258 | ($($body:tt)*) => { | |
1259 | $($body)* | |
1260 | }; | |
1261 | } | |
1262 | ||
1263 | #[cfg(feature = "unbounded_depth")] | |
1264 | macro_rules! if_checking_recursion_limit { | |
1265 | ($this:ident $($body:tt)*) => { | |
1266 | if !$this.disable_recursion_limit { | |
1267 | $this $($body)* | |
1268 | } | |
1269 | }; | |
1270 | } | |
1271 | ||
1272 | macro_rules! check_recursion { | |
1273 | ($this:ident $($body:tt)*) => { | |
1274 | if_checking_recursion_limit! { | |
1275 | $this.remaining_depth -= 1; | |
1276 | if $this.remaining_depth == 0 { | |
1277 | return Err($this.peek_error(ErrorCode::RecursionLimitExceeded)); | |
1278 | } | |
1279 | } | |
1280 | ||
1281 | $this $($body)* | |
1282 | ||
1283 | if_checking_recursion_limit! { | |
1284 | $this.remaining_depth += 1; | |
1285 | } | |
1286 | }; | |
1287 | } | |
1288 | ||
041b39d2 | 1289 | impl<'de, 'a, R: Read<'de>> de::Deserializer<'de> for &'a mut Deserializer<R> { |
7cac9316 XL |
1290 | type Error = Error; |
1291 | ||
1292 | #[inline] | |
041b39d2 XL |
1293 | fn deserialize_any<V>(self, visitor: V) -> Result<V::Value> |
1294 | where | |
1295 | V: de::Visitor<'de>, | |
7cac9316 | 1296 | { |
f035d41b | 1297 | let peek = match tri!(self.parse_whitespace()) { |
ff7c6d11 XL |
1298 | Some(b) => b, |
1299 | None => { | |
1300 | return Err(self.peek_error(ErrorCode::EofWhileParsingValue)); | |
1301 | } | |
1302 | }; | |
1303 | ||
1304 | let value = match peek { | |
1305 | b'n' => { | |
1306 | self.eat_char(); | |
f035d41b | 1307 | tri!(self.parse_ident(b"ull")); |
ff7c6d11 XL |
1308 | visitor.visit_unit() |
1309 | } | |
1310 | b't' => { | |
1311 | self.eat_char(); | |
f035d41b | 1312 | tri!(self.parse_ident(b"rue")); |
ff7c6d11 XL |
1313 | visitor.visit_bool(true) |
1314 | } | |
1315 | b'f' => { | |
1316 | self.eat_char(); | |
f035d41b | 1317 | tri!(self.parse_ident(b"alse")); |
ff7c6d11 XL |
1318 | visitor.visit_bool(false) |
1319 | } | |
1320 | b'-' => { | |
1321 | self.eat_char(); | |
f035d41b | 1322 | tri!(self.parse_any_number(false)).visit(visitor) |
0531ce1d | 1323 | } |
f035d41b | 1324 | b'0'..=b'9' => tri!(self.parse_any_number(true)).visit(visitor), |
ff7c6d11 XL |
1325 | b'"' => { |
1326 | self.eat_char(); | |
0bf4aa26 | 1327 | self.scratch.clear(); |
f035d41b | 1328 | match tri!(self.read.parse_str(&mut self.scratch)) { |
ff7c6d11 XL |
1329 | Reference::Borrowed(s) => visitor.visit_borrowed_str(s), |
1330 | Reference::Copied(s) => visitor.visit_str(s), | |
1331 | } | |
1332 | } | |
1333 | b'[' => { | |
416331ca XL |
1334 | check_recursion! { |
1335 | self.eat_char(); | |
1336 | let ret = visitor.visit_seq(SeqAccess::new(self)); | |
ff7c6d11 XL |
1337 | } |
1338 | ||
ff7c6d11 XL |
1339 | match (ret, self.end_seq()) { |
1340 | (Ok(ret), Ok(())) => Ok(ret), | |
1341 | (Err(err), _) | (_, Err(err)) => Err(err), | |
1342 | } | |
1343 | } | |
1344 | b'{' => { | |
416331ca XL |
1345 | check_recursion! { |
1346 | self.eat_char(); | |
1347 | let ret = visitor.visit_map(MapAccess::new(self)); | |
ff7c6d11 XL |
1348 | } |
1349 | ||
ff7c6d11 XL |
1350 | match (ret, self.end_map()) { |
1351 | (Ok(ret), Ok(())) => Ok(ret), | |
1352 | (Err(err), _) | (_, Err(err)) => Err(err), | |
1353 | } | |
1354 | } | |
1355 | _ => Err(self.peek_error(ErrorCode::ExpectedSomeValue)), | |
1356 | }; | |
1357 | ||
1358 | match value { | |
1359 | Ok(value) => Ok(value), | |
1360 | // The de::Error impl creates errors with unknown line and column. | |
1361 | // Fill in the position here by looking at the current index in the | |
1362 | // input. There is no way to tell whether this should call `error` | |
1363 | // or `peek_error` so pick the one that seems correct more often. | |
1364 | // Worst case, the position is off by one character. | |
1365 | Err(err) => Err(self.fix_position(err)), | |
1366 | } | |
7cac9316 XL |
1367 | } |
1368 | ||
ff7c6d11 | 1369 | fn deserialize_bool<V>(self, visitor: V) -> Result<V::Value> |
041b39d2 XL |
1370 | where |
1371 | V: de::Visitor<'de>, | |
7cac9316 | 1372 | { |
f035d41b | 1373 | let peek = match tri!(self.parse_whitespace()) { |
ff7c6d11 XL |
1374 | Some(b) => b, |
1375 | None => { | |
1376 | return Err(self.peek_error(ErrorCode::EofWhileParsingValue)); | |
1377 | } | |
1378 | }; | |
1379 | ||
1380 | let value = match peek { | |
1381 | b't' => { | |
7cac9316 | 1382 | self.eat_char(); |
f035d41b | 1383 | tri!(self.parse_ident(b"rue")); |
ff7c6d11 | 1384 | visitor.visit_bool(true) |
7cac9316 | 1385 | } |
ff7c6d11 XL |
1386 | b'f' => { |
1387 | self.eat_char(); | |
f035d41b | 1388 | tri!(self.parse_ident(b"alse")); |
ff7c6d11 XL |
1389 | visitor.visit_bool(false) |
1390 | } | |
1391 | _ => Err(self.peek_invalid_type(&visitor)), | |
1392 | }; | |
1393 | ||
1394 | match value { | |
1395 | Ok(value) => Ok(value), | |
1396 | Err(err) => Err(self.fix_position(err)), | |
7cac9316 XL |
1397 | } |
1398 | } | |
1399 | ||
f035d41b XL |
1400 | deserialize_number!(deserialize_i8); |
1401 | deserialize_number!(deserialize_i16); | |
1402 | deserialize_number!(deserialize_i32); | |
1403 | deserialize_number!(deserialize_i64); | |
1404 | deserialize_number!(deserialize_u8); | |
1405 | deserialize_number!(deserialize_u16); | |
1406 | deserialize_number!(deserialize_u32); | |
1407 | deserialize_number!(deserialize_u64); | |
1408 | #[cfg(not(feature = "float_roundtrip"))] | |
1409 | deserialize_number!(deserialize_f32); | |
1410 | deserialize_number!(deserialize_f64); | |
1411 | ||
1412 | #[cfg(feature = "float_roundtrip")] | |
1413 | fn deserialize_f32<V>(self, visitor: V) -> Result<V::Value> | |
1414 | where | |
1415 | V: de::Visitor<'de>, | |
1416 | { | |
1417 | self.single_precision = true; | |
1418 | let val = self.deserialize_number(visitor); | |
1419 | self.single_precision = false; | |
1420 | val | |
1421 | } | |
ff7c6d11 | 1422 | |
8faf50e0 XL |
1423 | serde_if_integer128! { |
1424 | fn deserialize_i128<V>(self, visitor: V) -> Result<V::Value> | |
1425 | where | |
1426 | V: de::Visitor<'de>, | |
1427 | { | |
1428 | let mut buf = String::new(); | |
1429 | ||
f035d41b | 1430 | match tri!(self.parse_whitespace()) { |
8faf50e0 XL |
1431 | Some(b'-') => { |
1432 | self.eat_char(); | |
1433 | buf.push('-'); | |
1434 | } | |
1435 | Some(_) => {} | |
1436 | None => { | |
1437 | return Err(self.peek_error(ErrorCode::EofWhileParsingValue)); | |
1438 | } | |
1439 | }; | |
1440 | ||
f035d41b | 1441 | tri!(self.scan_integer128(&mut buf)); |
8faf50e0 XL |
1442 | |
1443 | let value = match buf.parse() { | |
1444 | Ok(int) => visitor.visit_i128(int), | |
1445 | Err(_) => { | |
1446 | return Err(self.error(ErrorCode::NumberOutOfRange)); | |
1447 | } | |
1448 | }; | |
1449 | ||
1450 | match value { | |
1451 | Ok(value) => Ok(value), | |
1452 | Err(err) => Err(self.fix_position(err)), | |
1453 | } | |
1454 | } | |
1455 | ||
1456 | fn deserialize_u128<V>(self, visitor: V) -> Result<V::Value> | |
1457 | where | |
1458 | V: de::Visitor<'de>, | |
1459 | { | |
f035d41b | 1460 | match tri!(self.parse_whitespace()) { |
8faf50e0 XL |
1461 | Some(b'-') => { |
1462 | return Err(self.peek_error(ErrorCode::NumberOutOfRange)); | |
1463 | } | |
1464 | Some(_) => {} | |
1465 | None => { | |
1466 | return Err(self.peek_error(ErrorCode::EofWhileParsingValue)); | |
1467 | } | |
1468 | } | |
1469 | ||
1470 | let mut buf = String::new(); | |
f035d41b | 1471 | tri!(self.scan_integer128(&mut buf)); |
8faf50e0 XL |
1472 | |
1473 | let value = match buf.parse() { | |
1474 | Ok(int) => visitor.visit_u128(int), | |
1475 | Err(_) => { | |
1476 | return Err(self.error(ErrorCode::NumberOutOfRange)); | |
1477 | } | |
1478 | }; | |
1479 | ||
1480 | match value { | |
1481 | Ok(value) => Ok(value), | |
1482 | Err(err) => Err(self.fix_position(err)), | |
1483 | } | |
1484 | } | |
1485 | } | |
1486 | ||
ff7c6d11 XL |
1487 | fn deserialize_char<V>(self, visitor: V) -> Result<V::Value> |
1488 | where | |
1489 | V: de::Visitor<'de>, | |
1490 | { | |
1491 | self.deserialize_str(visitor) | |
1492 | } | |
1493 | ||
1494 | fn deserialize_str<V>(self, visitor: V) -> Result<V::Value> | |
1495 | where | |
1496 | V: de::Visitor<'de>, | |
1497 | { | |
f035d41b | 1498 | let peek = match tri!(self.parse_whitespace()) { |
ff7c6d11 XL |
1499 | Some(b) => b, |
1500 | None => { | |
1501 | return Err(self.peek_error(ErrorCode::EofWhileParsingValue)); | |
1502 | } | |
1503 | }; | |
1504 | ||
1505 | let value = match peek { | |
1506 | b'"' => { | |
1507 | self.eat_char(); | |
0bf4aa26 | 1508 | self.scratch.clear(); |
f035d41b | 1509 | match tri!(self.read.parse_str(&mut self.scratch)) { |
ff7c6d11 XL |
1510 | Reference::Borrowed(s) => visitor.visit_borrowed_str(s), |
1511 | Reference::Copied(s) => visitor.visit_str(s), | |
1512 | } | |
1513 | } | |
1514 | _ => Err(self.peek_invalid_type(&visitor)), | |
1515 | }; | |
1516 | ||
1517 | match value { | |
1518 | Ok(value) => Ok(value), | |
1519 | Err(err) => Err(self.fix_position(err)), | |
1520 | } | |
1521 | } | |
1522 | ||
1523 | fn deserialize_string<V>(self, visitor: V) -> Result<V::Value> | |
1524 | where | |
1525 | V: de::Visitor<'de>, | |
1526 | { | |
1527 | self.deserialize_str(visitor) | |
1528 | } | |
1529 | ||
1530 | /// Parses a JSON string as bytes. Note that this function does not check | |
1531 | /// whether the bytes represent a valid UTF-8 string. | |
1532 | /// | |
1533 | /// The relevant part of the JSON specification is Section 8.2 of [RFC | |
1534 | /// 7159]: | |
1535 | /// | |
1536 | /// > When all the strings represented in a JSON text are composed entirely | |
1537 | /// > of Unicode characters (however escaped), then that JSON text is | |
1538 | /// > interoperable in the sense that all software implementations that | |
1539 | /// > parse it will agree on the contents of names and of string values in | |
1540 | /// > objects and arrays. | |
1541 | /// > | |
1542 | /// > However, the ABNF in this specification allows member names and string | |
1543 | /// > values to contain bit sequences that cannot encode Unicode characters; | |
1544 | /// > for example, "\uDEAD" (a single unpaired UTF-16 surrogate). Instances | |
1545 | /// > of this have been observed, for example, when a library truncates a | |
1546 | /// > UTF-16 string without checking whether the truncation split a | |
1547 | /// > surrogate pair. The behavior of software that receives JSON texts | |
1548 | /// > containing such values is unpredictable; for example, implementations | |
1549 | /// > might return different values for the length of a string value or even | |
1550 | /// > suffer fatal runtime exceptions. | |
1551 | /// | |
1552 | /// [RFC 7159]: https://tools.ietf.org/html/rfc7159 | |
1553 | /// | |
1554 | /// The behavior of serde_json is specified to fail on non-UTF-8 strings | |
041b39d2 XL |
1555 | /// when deserializing into Rust UTF-8 string types such as String, and |
1556 | /// succeed with non-UTF-8 bytes when deserializing using this method. | |
7cac9316 | 1557 | /// |
041b39d2 XL |
1558 | /// Escape sequences are processed as usual, and for `\uXXXX` escapes it is |
1559 | /// still checked if the hex number represents a valid Unicode code point. | |
1560 | /// | |
1561 | /// # Examples | |
1562 | /// | |
1563 | /// You can use this to parse JSON strings containing invalid UTF-8 bytes. | |
1564 | /// | |
f035d41b | 1565 | /// ``` |
041b39d2 XL |
1566 | /// use serde_bytes::ByteBuf; |
1567 | /// | |
1568 | /// fn look_at_bytes() -> Result<(), serde_json::Error> { | |
1569 | /// let json_data = b"\"some bytes: \xe5\x00\xe5\""; | |
1570 | /// let bytes: ByteBuf = serde_json::from_slice(json_data)?; | |
1571 | /// | |
1572 | /// assert_eq!(b'\xe5', bytes[12]); | |
1573 | /// assert_eq!(b'\0', bytes[13]); | |
1574 | /// assert_eq!(b'\xe5', bytes[14]); | |
1575 | /// | |
1576 | /// Ok(()) | |
1577 | /// } | |
7cac9316 | 1578 | /// # |
f035d41b | 1579 | /// # look_at_bytes().unwrap(); |
7cac9316 XL |
1580 | /// ``` |
1581 | /// | |
041b39d2 XL |
1582 | /// Backslash escape sequences like `\n` are still interpreted and required |
1583 | /// to be valid, and `\u` escape sequences are required to represent valid | |
1584 | /// Unicode code points. | |
7cac9316 | 1585 | /// |
f035d41b | 1586 | /// ``` |
041b39d2 XL |
1587 | /// use serde_bytes::ByteBuf; |
1588 | /// | |
1589 | /// fn look_at_bytes() { | |
1590 | /// let json_data = b"\"invalid unicode surrogate: \\uD801\""; | |
1591 | /// let parsed: Result<ByteBuf, _> = serde_json::from_slice(json_data); | |
1592 | /// | |
1593 | /// assert!(parsed.is_err()); | |
1594 | /// | |
1595 | /// let expected_msg = "unexpected end of hex escape at line 1 column 35"; | |
1596 | /// assert_eq!(expected_msg, parsed.unwrap_err().to_string()); | |
1597 | /// } | |
7cac9316 | 1598 | /// # |
f035d41b | 1599 | /// # look_at_bytes(); |
7cac9316 XL |
1600 | /// ``` |
1601 | fn deserialize_bytes<V>(self, visitor: V) -> Result<V::Value> | |
041b39d2 XL |
1602 | where |
1603 | V: de::Visitor<'de>, | |
7cac9316 | 1604 | { |
f035d41b | 1605 | let peek = match tri!(self.parse_whitespace()) { |
ff7c6d11 XL |
1606 | Some(b) => b, |
1607 | None => { | |
1608 | return Err(self.peek_error(ErrorCode::EofWhileParsingValue)); | |
1609 | } | |
1610 | }; | |
1611 | ||
1612 | let value = match peek { | |
1613 | b'"' => { | |
7cac9316 | 1614 | self.eat_char(); |
0bf4aa26 | 1615 | self.scratch.clear(); |
f035d41b | 1616 | match tri!(self.read.parse_str_raw(&mut self.scratch)) { |
041b39d2 XL |
1617 | Reference::Borrowed(b) => visitor.visit_borrowed_bytes(b), |
1618 | Reference::Copied(b) => visitor.visit_bytes(b), | |
1619 | } | |
7cac9316 | 1620 | } |
ff7c6d11 XL |
1621 | b'[' => self.deserialize_seq(visitor), |
1622 | _ => Err(self.peek_invalid_type(&visitor)), | |
1623 | }; | |
7cac9316 | 1624 | |
ff7c6d11 XL |
1625 | match value { |
1626 | Ok(value) => Ok(value), | |
1627 | Err(err) => Err(self.fix_position(err)), | |
1628 | } | |
7cac9316 XL |
1629 | } |
1630 | ||
1631 | #[inline] | |
1632 | fn deserialize_byte_buf<V>(self, visitor: V) -> Result<V::Value> | |
041b39d2 XL |
1633 | where |
1634 | V: de::Visitor<'de>, | |
7cac9316 XL |
1635 | { |
1636 | self.deserialize_bytes(visitor) | |
1637 | } | |
1638 | ||
ff7c6d11 XL |
1639 | /// Parses a `null` as a None, and any other values as a `Some(...)`. |
1640 | #[inline] | |
1641 | fn deserialize_option<V>(self, visitor: V) -> Result<V::Value> | |
1642 | where | |
1643 | V: de::Visitor<'de>, | |
1644 | { | |
f035d41b | 1645 | match tri!(self.parse_whitespace()) { |
ff7c6d11 XL |
1646 | Some(b'n') => { |
1647 | self.eat_char(); | |
f035d41b | 1648 | tri!(self.parse_ident(b"ull")); |
ff7c6d11 XL |
1649 | visitor.visit_none() |
1650 | } | |
1651 | _ => visitor.visit_some(self), | |
1652 | } | |
1653 | } | |
1654 | ||
1655 | fn deserialize_unit<V>(self, visitor: V) -> Result<V::Value> | |
1656 | where | |
1657 | V: de::Visitor<'de>, | |
1658 | { | |
f035d41b | 1659 | let peek = match tri!(self.parse_whitespace()) { |
ff7c6d11 XL |
1660 | Some(b) => b, |
1661 | None => { | |
1662 | return Err(self.peek_error(ErrorCode::EofWhileParsingValue)); | |
1663 | } | |
1664 | }; | |
1665 | ||
1666 | let value = match peek { | |
1667 | b'n' => { | |
1668 | self.eat_char(); | |
f035d41b | 1669 | tri!(self.parse_ident(b"ull")); |
ff7c6d11 XL |
1670 | visitor.visit_unit() |
1671 | } | |
1672 | _ => Err(self.peek_invalid_type(&visitor)), | |
1673 | }; | |
1674 | ||
1675 | match value { | |
1676 | Ok(value) => Ok(value), | |
1677 | Err(err) => Err(self.fix_position(err)), | |
1678 | } | |
1679 | } | |
1680 | ||
83c7162d | 1681 | fn deserialize_unit_struct<V>(self, _name: &'static str, visitor: V) -> Result<V::Value> |
ff7c6d11 XL |
1682 | where |
1683 | V: de::Visitor<'de>, | |
1684 | { | |
1685 | self.deserialize_unit(visitor) | |
1686 | } | |
1687 | ||
1688 | /// Parses a newtype struct as the underlying value. | |
1689 | #[inline] | |
0bf4aa26 | 1690 | fn deserialize_newtype_struct<V>(self, name: &str, visitor: V) -> Result<V::Value> |
ff7c6d11 XL |
1691 | where |
1692 | V: de::Visitor<'de>, | |
1693 | { | |
0bf4aa26 XL |
1694 | #[cfg(feature = "raw_value")] |
1695 | { | |
f035d41b | 1696 | if name == crate::raw::TOKEN { |
0bf4aa26 XL |
1697 | return self.deserialize_raw_value(visitor); |
1698 | } | |
1699 | } | |
1700 | ||
1701 | let _ = name; | |
ff7c6d11 XL |
1702 | visitor.visit_newtype_struct(self) |
1703 | } | |
1704 | ||
1705 | fn deserialize_seq<V>(self, visitor: V) -> Result<V::Value> | |
1706 | where | |
1707 | V: de::Visitor<'de>, | |
1708 | { | |
f035d41b | 1709 | let peek = match tri!(self.parse_whitespace()) { |
ff7c6d11 XL |
1710 | Some(b) => b, |
1711 | None => { | |
1712 | return Err(self.peek_error(ErrorCode::EofWhileParsingValue)); | |
1713 | } | |
1714 | }; | |
1715 | ||
1716 | let value = match peek { | |
1717 | b'[' => { | |
416331ca XL |
1718 | check_recursion! { |
1719 | self.eat_char(); | |
1720 | let ret = visitor.visit_seq(SeqAccess::new(self)); | |
ff7c6d11 XL |
1721 | } |
1722 | ||
ff7c6d11 XL |
1723 | match (ret, self.end_seq()) { |
1724 | (Ok(ret), Ok(())) => Ok(ret), | |
1725 | (Err(err), _) | (_, Err(err)) => Err(err), | |
1726 | } | |
1727 | } | |
1728 | _ => Err(self.peek_invalid_type(&visitor)), | |
1729 | }; | |
1730 | ||
1731 | match value { | |
1732 | Ok(value) => Ok(value), | |
1733 | Err(err) => Err(self.fix_position(err)), | |
1734 | } | |
1735 | } | |
1736 | ||
83c7162d | 1737 | fn deserialize_tuple<V>(self, _len: usize, visitor: V) -> Result<V::Value> |
ff7c6d11 XL |
1738 | where |
1739 | V: de::Visitor<'de>, | |
1740 | { | |
1741 | self.deserialize_seq(visitor) | |
1742 | } | |
1743 | ||
1744 | fn deserialize_tuple_struct<V>( | |
1745 | self, | |
1746 | _name: &'static str, | |
1747 | _len: usize, | |
83c7162d | 1748 | visitor: V, |
ff7c6d11 XL |
1749 | ) -> Result<V::Value> |
1750 | where | |
1751 | V: de::Visitor<'de>, | |
1752 | { | |
1753 | self.deserialize_seq(visitor) | |
1754 | } | |
1755 | ||
1756 | fn deserialize_map<V>(self, visitor: V) -> Result<V::Value> | |
1757 | where | |
1758 | V: de::Visitor<'de>, | |
1759 | { | |
f035d41b | 1760 | let peek = match tri!(self.parse_whitespace()) { |
ff7c6d11 XL |
1761 | Some(b) => b, |
1762 | None => { | |
1763 | return Err(self.peek_error(ErrorCode::EofWhileParsingValue)); | |
1764 | } | |
1765 | }; | |
1766 | ||
1767 | let value = match peek { | |
1768 | b'{' => { | |
416331ca XL |
1769 | check_recursion! { |
1770 | self.eat_char(); | |
1771 | let ret = visitor.visit_map(MapAccess::new(self)); | |
ff7c6d11 XL |
1772 | } |
1773 | ||
ff7c6d11 XL |
1774 | match (ret, self.end_map()) { |
1775 | (Ok(ret), Ok(())) => Ok(ret), | |
1776 | (Err(err), _) | (_, Err(err)) => Err(err), | |
1777 | } | |
1778 | } | |
1779 | _ => Err(self.peek_invalid_type(&visitor)), | |
1780 | }; | |
1781 | ||
1782 | match value { | |
1783 | Ok(value) => Ok(value), | |
1784 | Err(err) => Err(self.fix_position(err)), | |
1785 | } | |
1786 | } | |
1787 | ||
1788 | fn deserialize_struct<V>( | |
1789 | self, | |
1790 | _name: &'static str, | |
1791 | _fields: &'static [&'static str], | |
83c7162d | 1792 | visitor: V, |
ff7c6d11 XL |
1793 | ) -> Result<V::Value> |
1794 | where | |
1795 | V: de::Visitor<'de>, | |
1796 | { | |
f035d41b | 1797 | let peek = match tri!(self.parse_whitespace()) { |
ff7c6d11 XL |
1798 | Some(b) => b, |
1799 | None => { | |
1800 | return Err(self.peek_error(ErrorCode::EofWhileParsingValue)); | |
1801 | } | |
1802 | }; | |
1803 | ||
1804 | let value = match peek { | |
1805 | b'[' => { | |
416331ca XL |
1806 | check_recursion! { |
1807 | self.eat_char(); | |
1808 | let ret = visitor.visit_seq(SeqAccess::new(self)); | |
ff7c6d11 XL |
1809 | } |
1810 | ||
ff7c6d11 XL |
1811 | match (ret, self.end_seq()) { |
1812 | (Ok(ret), Ok(())) => Ok(ret), | |
1813 | (Err(err), _) | (_, Err(err)) => Err(err), | |
1814 | } | |
1815 | } | |
1816 | b'{' => { | |
416331ca XL |
1817 | check_recursion! { |
1818 | self.eat_char(); | |
1819 | let ret = visitor.visit_map(MapAccess::new(self)); | |
ff7c6d11 XL |
1820 | } |
1821 | ||
ff7c6d11 XL |
1822 | match (ret, self.end_map()) { |
1823 | (Ok(ret), Ok(())) => Ok(ret), | |
1824 | (Err(err), _) | (_, Err(err)) => Err(err), | |
1825 | } | |
1826 | } | |
1827 | _ => Err(self.peek_invalid_type(&visitor)), | |
1828 | }; | |
1829 | ||
1830 | match value { | |
1831 | Ok(value) => Ok(value), | |
1832 | Err(err) => Err(self.fix_position(err)), | |
1833 | } | |
1834 | } | |
1835 | ||
1836 | /// Parses an enum as an object like `{"$KEY":$VALUE}`, where $VALUE is either a straight | |
1837 | /// value, a `[..]`, or a `{..}`. | |
1838 | #[inline] | |
1839 | fn deserialize_enum<V>( | |
1840 | self, | |
1841 | _name: &str, | |
1842 | _variants: &'static [&'static str], | |
1843 | visitor: V, | |
1844 | ) -> Result<V::Value> | |
1845 | where | |
1846 | V: de::Visitor<'de>, | |
1847 | { | |
f035d41b | 1848 | match tri!(self.parse_whitespace()) { |
ff7c6d11 | 1849 | Some(b'{') => { |
416331ca XL |
1850 | check_recursion! { |
1851 | self.eat_char(); | |
f035d41b | 1852 | let value = tri!(visitor.visit_enum(VariantAccess::new(self))); |
ff7c6d11 XL |
1853 | } |
1854 | ||
f035d41b | 1855 | match tri!(self.parse_whitespace()) { |
ff7c6d11 XL |
1856 | Some(b'}') => { |
1857 | self.eat_char(); | |
1858 | Ok(value) | |
1859 | } | |
1860 | Some(_) => Err(self.error(ErrorCode::ExpectedSomeValue)), | |
1861 | None => Err(self.error(ErrorCode::EofWhileParsingObject)), | |
1862 | } | |
1863 | } | |
1864 | Some(b'"') => visitor.visit_enum(UnitVariantAccess::new(self)), | |
1865 | Some(_) => Err(self.peek_error(ErrorCode::ExpectedSomeValue)), | |
1866 | None => Err(self.peek_error(ErrorCode::EofWhileParsingValue)), | |
1867 | } | |
1868 | } | |
1869 | ||
83c7162d | 1870 | fn deserialize_identifier<V>(self, visitor: V) -> Result<V::Value> |
ff7c6d11 XL |
1871 | where |
1872 | V: de::Visitor<'de>, | |
1873 | { | |
1874 | self.deserialize_str(visitor) | |
1875 | } | |
1876 | ||
ea8adc8c XL |
1877 | fn deserialize_ignored_any<V>(self, visitor: V) -> Result<V::Value> |
1878 | where | |
1879 | V: de::Visitor<'de>, | |
1880 | { | |
f035d41b | 1881 | tri!(self.ignore_value()); |
ea8adc8c XL |
1882 | visitor.visit_unit() |
1883 | } | |
7cac9316 XL |
1884 | } |
1885 | ||
041b39d2 | 1886 | struct SeqAccess<'a, R: 'a> { |
7cac9316 XL |
1887 | de: &'a mut Deserializer<R>, |
1888 | first: bool, | |
1889 | } | |
1890 | ||
041b39d2 | 1891 | impl<'a, R: 'a> SeqAccess<'a, R> { |
7cac9316 | 1892 | fn new(de: &'a mut Deserializer<R>) -> Self { |
f035d41b | 1893 | SeqAccess { de, first: true } |
7cac9316 XL |
1894 | } |
1895 | } | |
1896 | ||
041b39d2 | 1897 | impl<'de, 'a, R: Read<'de> + 'a> de::SeqAccess<'de> for SeqAccess<'a, R> { |
7cac9316 XL |
1898 | type Error = Error; |
1899 | ||
041b39d2 XL |
1900 | fn next_element_seed<T>(&mut self, seed: T) -> Result<Option<T::Value>> |
1901 | where | |
1902 | T: de::DeserializeSeed<'de>, | |
7cac9316 | 1903 | { |
f035d41b | 1904 | let peek = match tri!(self.de.parse_whitespace()) { |
7cac9316 XL |
1905 | Some(b']') => { |
1906 | return Ok(None); | |
1907 | } | |
1908 | Some(b',') if !self.first => { | |
1909 | self.de.eat_char(); | |
f035d41b | 1910 | tri!(self.de.parse_whitespace()) |
7cac9316 | 1911 | } |
abe05a73 | 1912 | Some(b) => { |
7cac9316 XL |
1913 | if self.first { |
1914 | self.first = false; | |
abe05a73 | 1915 | Some(b) |
7cac9316 | 1916 | } else { |
041b39d2 | 1917 | return Err(self.de.peek_error(ErrorCode::ExpectedListCommaOrEnd)); |
7cac9316 XL |
1918 | } |
1919 | } | |
1920 | None => { | |
1921 | return Err(self.de.peek_error(ErrorCode::EofWhileParsingList)); | |
1922 | } | |
abe05a73 | 1923 | }; |
7cac9316 | 1924 | |
abe05a73 XL |
1925 | match peek { |
1926 | Some(b']') => Err(self.de.peek_error(ErrorCode::TrailingComma)), | |
f035d41b | 1927 | Some(_) => Ok(Some(tri!(seed.deserialize(&mut *self.de)))), |
abe05a73 XL |
1928 | None => Err(self.de.peek_error(ErrorCode::EofWhileParsingValue)), |
1929 | } | |
7cac9316 XL |
1930 | } |
1931 | } | |
1932 | ||
041b39d2 | 1933 | struct MapAccess<'a, R: 'a> { |
7cac9316 XL |
1934 | de: &'a mut Deserializer<R>, |
1935 | first: bool, | |
1936 | } | |
1937 | ||
041b39d2 | 1938 | impl<'a, R: 'a> MapAccess<'a, R> { |
7cac9316 | 1939 | fn new(de: &'a mut Deserializer<R>) -> Self { |
f035d41b | 1940 | MapAccess { de, first: true } |
7cac9316 XL |
1941 | } |
1942 | } | |
1943 | ||
041b39d2 | 1944 | impl<'de, 'a, R: Read<'de> + 'a> de::MapAccess<'de> for MapAccess<'a, R> { |
7cac9316 XL |
1945 | type Error = Error; |
1946 | ||
041b39d2 XL |
1947 | fn next_key_seed<K>(&mut self, seed: K) -> Result<Option<K::Value>> |
1948 | where | |
1949 | K: de::DeserializeSeed<'de>, | |
7cac9316 | 1950 | { |
f035d41b | 1951 | let peek = match tri!(self.de.parse_whitespace()) { |
7cac9316 XL |
1952 | Some(b'}') => { |
1953 | return Ok(None); | |
1954 | } | |
1955 | Some(b',') if !self.first => { | |
1956 | self.de.eat_char(); | |
f035d41b | 1957 | tri!(self.de.parse_whitespace()) |
7cac9316 | 1958 | } |
041b39d2 | 1959 | Some(b) => { |
7cac9316 XL |
1960 | if self.first { |
1961 | self.first = false; | |
041b39d2 | 1962 | Some(b) |
7cac9316 | 1963 | } else { |
041b39d2 | 1964 | return Err(self.de.peek_error(ErrorCode::ExpectedObjectCommaOrEnd)); |
7cac9316 XL |
1965 | } |
1966 | } | |
1967 | None => { | |
041b39d2 | 1968 | return Err(self.de.peek_error(ErrorCode::EofWhileParsingObject)); |
7cac9316 | 1969 | } |
041b39d2 | 1970 | }; |
7cac9316 | 1971 | |
041b39d2 XL |
1972 | match peek { |
1973 | Some(b'"') => seed.deserialize(MapKey { de: &mut *self.de }).map(Some), | |
abe05a73 | 1974 | Some(b'}') => Err(self.de.peek_error(ErrorCode::TrailingComma)), |
7cac9316 XL |
1975 | Some(_) => Err(self.de.peek_error(ErrorCode::KeyMustBeAString)), |
1976 | None => Err(self.de.peek_error(ErrorCode::EofWhileParsingValue)), | |
1977 | } | |
1978 | } | |
1979 | ||
041b39d2 XL |
1980 | fn next_value_seed<V>(&mut self, seed: V) -> Result<V::Value> |
1981 | where | |
1982 | V: de::DeserializeSeed<'de>, | |
7cac9316 | 1983 | { |
f035d41b | 1984 | tri!(self.de.parse_object_colon()); |
7cac9316 XL |
1985 | |
1986 | seed.deserialize(&mut *self.de) | |
1987 | } | |
1988 | } | |
1989 | ||
041b39d2 | 1990 | struct VariantAccess<'a, R: 'a> { |
7cac9316 XL |
1991 | de: &'a mut Deserializer<R>, |
1992 | } | |
1993 | ||
041b39d2 | 1994 | impl<'a, R: 'a> VariantAccess<'a, R> { |
7cac9316 | 1995 | fn new(de: &'a mut Deserializer<R>) -> Self { |
f035d41b | 1996 | VariantAccess { de } |
7cac9316 XL |
1997 | } |
1998 | } | |
1999 | ||
041b39d2 | 2000 | impl<'de, 'a, R: Read<'de> + 'a> de::EnumAccess<'de> for VariantAccess<'a, R> { |
7cac9316 XL |
2001 | type Error = Error; |
2002 | type Variant = Self; | |
2003 | ||
041b39d2 XL |
2004 | fn variant_seed<V>(self, seed: V) -> Result<(V::Value, Self)> |
2005 | where | |
2006 | V: de::DeserializeSeed<'de>, | |
7cac9316 | 2007 | { |
f035d41b XL |
2008 | let val = tri!(seed.deserialize(&mut *self.de)); |
2009 | tri!(self.de.parse_object_colon()); | |
7cac9316 XL |
2010 | Ok((val, self)) |
2011 | } | |
2012 | } | |
2013 | ||
041b39d2 | 2014 | impl<'de, 'a, R: Read<'de> + 'a> de::VariantAccess<'de> for VariantAccess<'a, R> { |
7cac9316 XL |
2015 | type Error = Error; |
2016 | ||
041b39d2 | 2017 | fn unit_variant(self) -> Result<()> { |
7cac9316 XL |
2018 | de::Deserialize::deserialize(self.de) |
2019 | } | |
2020 | ||
041b39d2 XL |
2021 | fn newtype_variant_seed<T>(self, seed: T) -> Result<T::Value> |
2022 | where | |
2023 | T: de::DeserializeSeed<'de>, | |
7cac9316 XL |
2024 | { |
2025 | seed.deserialize(self.de) | |
2026 | } | |
2027 | ||
041b39d2 XL |
2028 | fn tuple_variant<V>(self, _len: usize, visitor: V) -> Result<V::Value> |
2029 | where | |
2030 | V: de::Visitor<'de>, | |
7cac9316 | 2031 | { |
ff7c6d11 | 2032 | de::Deserializer::deserialize_seq(self.de, visitor) |
7cac9316 XL |
2033 | } |
2034 | ||
ff7c6d11 | 2035 | fn struct_variant<V>(self, fields: &'static [&'static str], visitor: V) -> Result<V::Value> |
041b39d2 XL |
2036 | where |
2037 | V: de::Visitor<'de>, | |
7cac9316 | 2038 | { |
ff7c6d11 | 2039 | de::Deserializer::deserialize_struct(self.de, "", fields, visitor) |
7cac9316 XL |
2040 | } |
2041 | } | |
2042 | ||
041b39d2 | 2043 | struct UnitVariantAccess<'a, R: 'a> { |
7cac9316 XL |
2044 | de: &'a mut Deserializer<R>, |
2045 | } | |
2046 | ||
041b39d2 | 2047 | impl<'a, R: 'a> UnitVariantAccess<'a, R> { |
7cac9316 | 2048 | fn new(de: &'a mut Deserializer<R>) -> Self { |
f035d41b | 2049 | UnitVariantAccess { de } |
7cac9316 XL |
2050 | } |
2051 | } | |
2052 | ||
041b39d2 | 2053 | impl<'de, 'a, R: Read<'de> + 'a> de::EnumAccess<'de> for UnitVariantAccess<'a, R> { |
7cac9316 XL |
2054 | type Error = Error; |
2055 | type Variant = Self; | |
2056 | ||
041b39d2 XL |
2057 | fn variant_seed<V>(self, seed: V) -> Result<(V::Value, Self)> |
2058 | where | |
2059 | V: de::DeserializeSeed<'de>, | |
7cac9316 | 2060 | { |
f035d41b | 2061 | let variant = tri!(seed.deserialize(&mut *self.de)); |
7cac9316 XL |
2062 | Ok((variant, self)) |
2063 | } | |
2064 | } | |
2065 | ||
041b39d2 | 2066 | impl<'de, 'a, R: Read<'de> + 'a> de::VariantAccess<'de> for UnitVariantAccess<'a, R> { |
7cac9316 XL |
2067 | type Error = Error; |
2068 | ||
041b39d2 | 2069 | fn unit_variant(self) -> Result<()> { |
7cac9316 XL |
2070 | Ok(()) |
2071 | } | |
2072 | ||
041b39d2 XL |
2073 | fn newtype_variant_seed<T>(self, _seed: T) -> Result<T::Value> |
2074 | where | |
2075 | T: de::DeserializeSeed<'de>, | |
2076 | { | |
83c7162d XL |
2077 | Err(de::Error::invalid_type( |
2078 | Unexpected::UnitVariant, | |
2079 | &"newtype variant", | |
2080 | )) | |
041b39d2 XL |
2081 | } |
2082 | ||
2083 | fn tuple_variant<V>(self, _len: usize, _visitor: V) -> Result<V::Value> | |
2084 | where | |
2085 | V: de::Visitor<'de>, | |
7cac9316 | 2086 | { |
83c7162d XL |
2087 | Err(de::Error::invalid_type( |
2088 | Unexpected::UnitVariant, | |
2089 | &"tuple variant", | |
2090 | )) | |
7cac9316 XL |
2091 | } |
2092 | ||
041b39d2 XL |
2093 | fn struct_variant<V>(self, _fields: &'static [&'static str], _visitor: V) -> Result<V::Value> |
2094 | where | |
2095 | V: de::Visitor<'de>, | |
7cac9316 | 2096 | { |
83c7162d XL |
2097 | Err(de::Error::invalid_type( |
2098 | Unexpected::UnitVariant, | |
2099 | &"struct variant", | |
2100 | )) | |
041b39d2 XL |
2101 | } |
2102 | } | |
2103 | ||
2104 | /// Only deserialize from this after peeking a '"' byte! Otherwise it may | |
2105 | /// deserialize invalid JSON successfully. | |
2106 | struct MapKey<'a, R: 'a> { | |
2107 | de: &'a mut Deserializer<R>, | |
2108 | } | |
2109 | ||
2110 | macro_rules! deserialize_integer_key { | |
0531ce1d XL |
2111 | ($method:ident => $visit:ident) => { |
2112 | fn $method<V>(self, visitor: V) -> Result<V::Value> | |
041b39d2 XL |
2113 | where |
2114 | V: de::Visitor<'de>, | |
2115 | { | |
2116 | self.de.eat_char(); | |
0bf4aa26 | 2117 | self.de.scratch.clear(); |
f035d41b | 2118 | let string = tri!(self.de.read.parse_str(&mut self.de.scratch)); |
041b39d2 XL |
2119 | match (string.parse(), string) { |
2120 | (Ok(integer), _) => visitor.$visit(integer), | |
2121 | (Err(_), Reference::Borrowed(s)) => visitor.visit_borrowed_str(s), | |
2122 | (Err(_), Reference::Copied(s)) => visitor.visit_str(s), | |
2123 | } | |
2124 | } | |
f035d41b | 2125 | }; |
041b39d2 | 2126 | } |
7cac9316 | 2127 | |
041b39d2 XL |
2128 | impl<'de, 'a, R> de::Deserializer<'de> for MapKey<'a, R> |
2129 | where | |
2130 | R: Read<'de>, | |
2131 | { | |
2132 | type Error = Error; | |
2133 | ||
2134 | #[inline] | |
2135 | fn deserialize_any<V>(self, visitor: V) -> Result<V::Value> | |
2136 | where | |
2137 | V: de::Visitor<'de>, | |
2138 | { | |
ff7c6d11 | 2139 | self.de.eat_char(); |
0bf4aa26 | 2140 | self.de.scratch.clear(); |
f035d41b | 2141 | match tri!(self.de.read.parse_str(&mut self.de.scratch)) { |
ff7c6d11 XL |
2142 | Reference::Borrowed(s) => visitor.visit_borrowed_str(s), |
2143 | Reference::Copied(s) => visitor.visit_str(s), | |
2144 | } | |
041b39d2 XL |
2145 | } |
2146 | ||
2147 | deserialize_integer_key!(deserialize_i8 => visit_i8); | |
2148 | deserialize_integer_key!(deserialize_i16 => visit_i16); | |
2149 | deserialize_integer_key!(deserialize_i32 => visit_i32); | |
2150 | deserialize_integer_key!(deserialize_i64 => visit_i64); | |
2151 | deserialize_integer_key!(deserialize_u8 => visit_u8); | |
2152 | deserialize_integer_key!(deserialize_u16 => visit_u16); | |
2153 | deserialize_integer_key!(deserialize_u32 => visit_u32); | |
2154 | deserialize_integer_key!(deserialize_u64 => visit_u64); | |
2155 | ||
8faf50e0 XL |
2156 | serde_if_integer128! { |
2157 | deserialize_integer_key!(deserialize_i128 => visit_i128); | |
2158 | deserialize_integer_key!(deserialize_u128 => visit_u128); | |
2159 | } | |
2160 | ||
041b39d2 XL |
2161 | #[inline] |
2162 | fn deserialize_option<V>(self, visitor: V) -> Result<V::Value> | |
2163 | where | |
2164 | V: de::Visitor<'de>, | |
2165 | { | |
2166 | // Map keys cannot be null. | |
2167 | visitor.visit_some(self) | |
2168 | } | |
2169 | ||
2170 | #[inline] | |
2171 | fn deserialize_newtype_struct<V>(self, _name: &'static str, visitor: V) -> Result<V::Value> | |
2172 | where | |
2173 | V: de::Visitor<'de>, | |
2174 | { | |
2175 | visitor.visit_newtype_struct(self) | |
2176 | } | |
2177 | ||
2178 | #[inline] | |
2179 | fn deserialize_enum<V>( | |
7cac9316 | 2180 | self, |
041b39d2 XL |
2181 | name: &'static str, |
2182 | variants: &'static [&'static str], | |
2183 | visitor: V, | |
7cac9316 | 2184 | ) -> Result<V::Value> |
041b39d2 XL |
2185 | where |
2186 | V: de::Visitor<'de>, | |
2187 | { | |
2188 | self.de.deserialize_enum(name, variants, visitor) | |
2189 | } | |
2190 | ||
2191 | #[inline] | |
2192 | fn deserialize_bytes<V>(self, visitor: V) -> Result<V::Value> | |
2193 | where | |
2194 | V: de::Visitor<'de>, | |
2195 | { | |
2196 | self.de.deserialize_bytes(visitor) | |
2197 | } | |
2198 | ||
2199 | #[inline] | |
2200 | fn deserialize_byte_buf<V>(self, visitor: V) -> Result<V::Value> | |
2201 | where | |
2202 | V: de::Visitor<'de>, | |
7cac9316 | 2203 | { |
041b39d2 XL |
2204 | self.de.deserialize_bytes(visitor) |
2205 | } | |
2206 | ||
2207 | forward_to_deserialize_any! { | |
2208 | bool f32 f64 char str string unit unit_struct seq tuple tuple_struct map | |
2209 | struct identifier ignored_any | |
7cac9316 XL |
2210 | } |
2211 | } | |
2212 | ||
2213 | ////////////////////////////////////////////////////////////////////////////// | |
2214 | ||
2215 | /// Iterator that deserializes a stream into multiple JSON values. | |
2216 | /// | |
2217 | /// A stream deserializer can be created from any JSON deserializer using the | |
2218 | /// `Deserializer::into_iter` method. | |
2219 | /// | |
ff7c6d11 XL |
2220 | /// The data can consist of any JSON value. Values need to be a self-delineating value e.g. |
2221 | /// arrays, objects, or strings, or be followed by whitespace or a self-delineating value. | |
041b39d2 | 2222 | /// |
f035d41b | 2223 | /// ``` |
7cac9316 XL |
2224 | /// use serde_json::{Deserializer, Value}; |
2225 | /// | |
2226 | /// fn main() { | |
ff7c6d11 | 2227 | /// let data = "{\"k\": 3}1\"cool\"\"stuff\" 3{} [0, 1, 2]"; |
7cac9316 XL |
2228 | /// |
2229 | /// let stream = Deserializer::from_str(data).into_iter::<Value>(); | |
2230 | /// | |
2231 | /// for value in stream { | |
2232 | /// println!("{}", value.unwrap()); | |
2233 | /// } | |
2234 | /// } | |
2235 | /// ``` | |
041b39d2 | 2236 | pub struct StreamDeserializer<'de, R, T> { |
7cac9316 | 2237 | de: Deserializer<R>, |
041b39d2 | 2238 | offset: usize, |
f035d41b | 2239 | failed: bool, |
041b39d2 XL |
2240 | output: PhantomData<T>, |
2241 | lifetime: PhantomData<&'de ()>, | |
7cac9316 XL |
2242 | } |
2243 | ||
041b39d2 XL |
2244 | impl<'de, R, T> StreamDeserializer<'de, R, T> |
2245 | where | |
2246 | R: read::Read<'de>, | |
2247 | T: de::Deserialize<'de>, | |
7cac9316 XL |
2248 | { |
2249 | /// Create a JSON stream deserializer from one of the possible serde_json | |
2250 | /// input sources. | |
2251 | /// | |
2252 | /// Typically it is more convenient to use one of these methods instead: | |
2253 | /// | |
2254 | /// - Deserializer::from_str(...).into_iter() | |
6a06907d | 2255 | /// - Deserializer::from_slice(...).into_iter() |
7cac9316 XL |
2256 | /// - Deserializer::from_reader(...).into_iter() |
2257 | pub fn new(read: R) -> Self { | |
041b39d2 | 2258 | let offset = read.byte_offset(); |
7cac9316 XL |
2259 | StreamDeserializer { |
2260 | de: Deserializer::new(read), | |
f035d41b XL |
2261 | offset, |
2262 | failed: false, | |
041b39d2 XL |
2263 | output: PhantomData, |
2264 | lifetime: PhantomData, | |
7cac9316 XL |
2265 | } |
2266 | } | |
041b39d2 XL |
2267 | |
2268 | /// Returns the number of bytes so far deserialized into a successful `T`. | |
2269 | /// | |
2270 | /// If a stream deserializer returns an EOF error, new data can be joined to | |
2271 | /// `old_data[stream.byte_offset()..]` to try again. | |
2272 | /// | |
f035d41b | 2273 | /// ``` |
041b39d2 XL |
2274 | /// let data = b"[0] [1] ["; |
2275 | /// | |
2276 | /// let de = serde_json::Deserializer::from_slice(data); | |
2277 | /// let mut stream = de.into_iter::<Vec<i32>>(); | |
2278 | /// assert_eq!(0, stream.byte_offset()); | |
2279 | /// | |
2280 | /// println!("{:?}", stream.next()); // [0] | |
2281 | /// assert_eq!(3, stream.byte_offset()); | |
2282 | /// | |
2283 | /// println!("{:?}", stream.next()); // [1] | |
2284 | /// assert_eq!(7, stream.byte_offset()); | |
2285 | /// | |
2286 | /// println!("{:?}", stream.next()); // error | |
2287 | /// assert_eq!(8, stream.byte_offset()); | |
2288 | /// | |
2289 | /// // If err.is_eof(), can join the remaining data to new data and continue. | |
2290 | /// let remaining = &data[stream.byte_offset()..]; | |
2291 | /// ``` | |
2292 | /// | |
2293 | /// *Note:* In the future this method may be changed to return the number of | |
2294 | /// bytes so far deserialized into a successful T *or* syntactically valid | |
2295 | /// JSON skipped over due to a type error. See [serde-rs/json#70] for an | |
2296 | /// example illustrating this. | |
2297 | /// | |
2298 | /// [serde-rs/json#70]: https://github.com/serde-rs/json/issues/70 | |
2299 | pub fn byte_offset(&self) -> usize { | |
2300 | self.offset | |
2301 | } | |
ff7c6d11 XL |
2302 | |
2303 | fn peek_end_of_value(&mut self) -> Result<()> { | |
f035d41b | 2304 | match tri!(self.de.peek()) { |
83c7162d XL |
2305 | Some(b' ') | Some(b'\n') | Some(b'\t') | Some(b'\r') | Some(b'"') | Some(b'[') |
2306 | | Some(b']') | Some(b'{') | Some(b'}') | Some(b',') | Some(b':') | None => Ok(()), | |
ff7c6d11 | 2307 | Some(_) => { |
83c7162d XL |
2308 | let position = self.de.read.peek_position(); |
2309 | Err(Error::syntax( | |
2310 | ErrorCode::TrailingCharacters, | |
2311 | position.line, | |
2312 | position.column, | |
2313 | )) | |
2314 | } | |
ff7c6d11 XL |
2315 | } |
2316 | } | |
7cac9316 XL |
2317 | } |
2318 | ||
041b39d2 XL |
2319 | impl<'de, R, T> Iterator for StreamDeserializer<'de, R, T> |
2320 | where | |
2321 | R: Read<'de>, | |
2322 | T: de::Deserialize<'de>, | |
7cac9316 XL |
2323 | { |
2324 | type Item = Result<T>; | |
2325 | ||
2326 | fn next(&mut self) -> Option<Result<T>> { | |
f035d41b XL |
2327 | if R::should_early_return_if_failed && self.failed { |
2328 | return None; | |
2329 | } | |
2330 | ||
7cac9316 XL |
2331 | // skip whitespaces, if any |
2332 | // this helps with trailing whitespaces, since whitespaces between | |
2333 | // values are handled for us. | |
2334 | match self.de.parse_whitespace() { | |
041b39d2 XL |
2335 | Ok(None) => { |
2336 | self.offset = self.de.read.byte_offset(); | |
2337 | None | |
2338 | } | |
ff7c6d11 XL |
2339 | Ok(Some(b)) => { |
2340 | // If the value does not have a clear way to show the end of the value | |
2341 | // (like numbers, null, true etc.) we have to look for whitespace or | |
2342 | // the beginning of a self-delineated value. | |
2343 | let self_delineated_value = match b { | |
2344 | b'[' | b'"' | b'{' => true, | |
2345 | _ => false, | |
2346 | }; | |
041b39d2 XL |
2347 | self.offset = self.de.read.byte_offset(); |
2348 | let result = de::Deserialize::deserialize(&mut self.de); | |
ff7c6d11 XL |
2349 | |
2350 | Some(match result { | |
2351 | Ok(value) => { | |
2352 | self.offset = self.de.read.byte_offset(); | |
2353 | if self_delineated_value { | |
2354 | Ok(value) | |
2355 | } else { | |
2356 | self.peek_end_of_value().map(|_| value) | |
2357 | } | |
2358 | } | |
f035d41b XL |
2359 | Err(e) => { |
2360 | self.de.read.set_failed(&mut self.failed); | |
2361 | Err(e) | |
2362 | } | |
ff7c6d11 | 2363 | }) |
7cac9316 | 2364 | } |
f035d41b XL |
2365 | Err(e) => { |
2366 | self.de.read.set_failed(&mut self.failed); | |
2367 | Some(Err(e)) | |
2368 | } | |
7cac9316 XL |
2369 | } |
2370 | } | |
2371 | } | |
2372 | ||
f035d41b XL |
2373 | impl<'de, R, T> FusedIterator for StreamDeserializer<'de, R, T> |
2374 | where | |
2375 | R: Read<'de> + Fused, | |
2376 | T: de::Deserialize<'de>, | |
2377 | { | |
2378 | } | |
2379 | ||
7cac9316 XL |
2380 | ////////////////////////////////////////////////////////////////////////////// |
2381 | ||
041b39d2 XL |
2382 | fn from_trait<'de, R, T>(read: R) -> Result<T> |
2383 | where | |
2384 | R: Read<'de>, | |
2385 | T: de::Deserialize<'de>, | |
7cac9316 XL |
2386 | { |
2387 | let mut de = Deserializer::new(read); | |
f035d41b | 2388 | let value = tri!(de::Deserialize::deserialize(&mut de)); |
7cac9316 XL |
2389 | |
2390 | // Make sure the whole stream has been consumed. | |
f035d41b | 2391 | tri!(de.end()); |
7cac9316 XL |
2392 | Ok(value) |
2393 | } | |
2394 | ||
7cac9316 XL |
2395 | /// Deserialize an instance of type `T` from an IO stream of JSON. |
2396 | /// | |
416331ca XL |
2397 | /// The content of the IO stream is deserialized directly from the stream |
2398 | /// without being buffered in memory by serde_json. | |
041b39d2 | 2399 | /// |
416331ca XL |
2400 | /// When reading from a source against which short reads are not efficient, such |
2401 | /// as a [`File`], you will want to apply your own buffering because serde_json | |
2402 | /// will not buffer the input. See [`std::io::BufReader`]. | |
2403 | /// | |
f035d41b XL |
2404 | /// It is expected that the input stream ends after the deserialized object. |
2405 | /// If the stream does not end, such as in the case of a persistent socket connection, | |
2406 | /// this function will not return. It is possible instead to deserialize from a prefix of an input | |
2407 | /// stream without looking for EOF by managing your own [`Deserializer`]. | |
2408 | /// | |
2409 | /// Note that counter to intuition, this function is usually slower than | |
2410 | /// reading a file completely into memory and then applying [`from_str`] | |
2411 | /// or [`from_slice`] on it. See [issue #160]. | |
2412 | /// | |
416331ca | 2413 | /// [`File`]: https://doc.rust-lang.org/std/fs/struct.File.html |
f035d41b XL |
2414 | /// [`std::io::BufReader`]: https://doc.rust-lang.org/std/io/struct.BufReader.html |
2415 | /// [`from_str`]: ./fn.from_str.html | |
2416 | /// [`from_slice`]: ./fn.from_slice.html | |
2417 | /// [issue #160]: https://github.com/serde-rs/json/issues/160 | |
041b39d2 | 2418 | /// |
416331ca | 2419 | /// # Example |
041b39d2 | 2420 | /// |
f035d41b XL |
2421 | /// Reading the contents of a file. |
2422 | /// | |
2423 | /// ``` | |
416331ca | 2424 | /// use serde::Deserialize; |
041b39d2 XL |
2425 | /// |
2426 | /// use std::error::Error; | |
2427 | /// use std::fs::File; | |
416331ca | 2428 | /// use std::io::BufReader; |
041b39d2 XL |
2429 | /// use std::path::Path; |
2430 | /// | |
2431 | /// #[derive(Deserialize, Debug)] | |
2432 | /// struct User { | |
2433 | /// fingerprint: String, | |
2434 | /// location: String, | |
2435 | /// } | |
2436 | /// | |
6a06907d | 2437 | /// fn read_user_from_file<P: AsRef<Path>>(path: P) -> Result<User, Box<dyn Error>> { |
416331ca | 2438 | /// // Open the file in read-only mode with buffer. |
041b39d2 | 2439 | /// let file = File::open(path)?; |
416331ca | 2440 | /// let reader = BufReader::new(file); |
041b39d2 XL |
2441 | /// |
2442 | /// // Read the JSON contents of the file as an instance of `User`. | |
416331ca | 2443 | /// let u = serde_json::from_reader(reader)?; |
041b39d2 XL |
2444 | /// |
2445 | /// // Return the `User`. | |
2446 | /// Ok(u) | |
2447 | /// } | |
2448 | /// | |
2449 | /// fn main() { | |
2450 | /// # } | |
2451 | /// # fn fake_main() { | |
2452 | /// let u = read_user_from_file("test.json").unwrap(); | |
2453 | /// println!("{:#?}", u); | |
2454 | /// } | |
2455 | /// ``` | |
7cac9316 | 2456 | /// |
f035d41b XL |
2457 | /// Reading from a persistent socket connection. |
2458 | /// | |
2459 | /// ``` | |
2460 | /// use serde::Deserialize; | |
2461 | /// | |
2462 | /// use std::error::Error; | |
2463 | /// use std::net::{TcpListener, TcpStream}; | |
2464 | /// | |
2465 | /// #[derive(Deserialize, Debug)] | |
2466 | /// struct User { | |
2467 | /// fingerprint: String, | |
2468 | /// location: String, | |
2469 | /// } | |
2470 | /// | |
2471 | /// fn read_user_from_stream(tcp_stream: TcpStream) -> Result<User, Box<dyn Error>> { | |
2472 | /// let mut de = serde_json::Deserializer::from_reader(tcp_stream); | |
2473 | /// let u = User::deserialize(&mut de)?; | |
2474 | /// | |
2475 | /// Ok(u) | |
2476 | /// } | |
2477 | /// | |
2478 | /// fn main() { | |
2479 | /// # } | |
2480 | /// # fn fake_main() { | |
2481 | /// let listener = TcpListener::bind("127.0.0.1:4000").unwrap(); | |
2482 | /// | |
2483 | /// for stream in listener.incoming() { | |
2484 | /// println!("{:#?}", read_user_from_stream(stream.unwrap())); | |
2485 | /// } | |
2486 | /// } | |
2487 | /// ``` | |
2488 | /// | |
041b39d2 XL |
2489 | /// # Errors |
2490 | /// | |
2491 | /// This conversion can fail if the structure of the input does not match the | |
2492 | /// structure expected by `T`, for example if `T` is a struct type but the input | |
7cac9316 XL |
2493 | /// contains something other than a JSON map. It can also fail if the structure |
2494 | /// is correct but `T`'s implementation of `Deserialize` decides that something | |
2495 | /// is wrong with the data, for example required struct fields are missing from | |
2496 | /// the JSON map or some number is too big to fit in the expected primitive | |
2497 | /// type. | |
f035d41b | 2498 | #[cfg(feature = "std")] |
94222f64 | 2499 | #[cfg_attr(docsrs, doc(cfg(feature = "std")))] |
416331ca XL |
2500 | pub fn from_reader<R, T>(rdr: R) -> Result<T> |
2501 | where | |
f035d41b | 2502 | R: crate::io::Read, |
416331ca XL |
2503 | T: de::DeserializeOwned, |
2504 | { | |
2505 | from_trait(read::IoRead::new(rdr)) | |
2506 | } | |
2507 | ||
2508 | /// Deserialize an instance of type `T` from bytes of JSON text. | |
041b39d2 | 2509 | /// |
416331ca | 2510 | /// # Example |
041b39d2 | 2511 | /// |
f035d41b | 2512 | /// ``` |
416331ca | 2513 | /// use serde::Deserialize; |
041b39d2 XL |
2514 | /// |
2515 | /// #[derive(Deserialize, Debug)] | |
2516 | /// struct User { | |
2517 | /// fingerprint: String, | |
2518 | /// location: String, | |
2519 | /// } | |
2520 | /// | |
2521 | /// fn main() { | |
2522 | /// // The type of `j` is `&[u8]` | |
416331ca XL |
2523 | /// let j = b" |
2524 | /// { | |
2525 | /// \"fingerprint\": \"0xF9BA143B95FF6D82\", | |
2526 | /// \"location\": \"Menlo Park, CA\" | |
2527 | /// }"; | |
041b39d2 XL |
2528 | /// |
2529 | /// let u: User = serde_json::from_slice(j).unwrap(); | |
2530 | /// println!("{:#?}", u); | |
2531 | /// } | |
2532 | /// ``` | |
7cac9316 | 2533 | /// |
041b39d2 XL |
2534 | /// # Errors |
2535 | /// | |
2536 | /// This conversion can fail if the structure of the input does not match the | |
2537 | /// structure expected by `T`, for example if `T` is a struct type but the input | |
7cac9316 XL |
2538 | /// contains something other than a JSON map. It can also fail if the structure |
2539 | /// is correct but `T`'s implementation of `Deserialize` decides that something | |
2540 | /// is wrong with the data, for example required struct fields are missing from | |
2541 | /// the JSON map or some number is too big to fit in the expected primitive | |
2542 | /// type. | |
416331ca XL |
2543 | pub fn from_slice<'a, T>(v: &'a [u8]) -> Result<T> |
2544 | where | |
2545 | T: de::Deserialize<'a>, | |
2546 | { | |
2547 | from_trait(read::SliceRead::new(v)) | |
2548 | } | |
2549 | ||
2550 | /// Deserialize an instance of type `T` from a string of JSON text. | |
041b39d2 | 2551 | /// |
416331ca | 2552 | /// # Example |
041b39d2 | 2553 | /// |
f035d41b | 2554 | /// ``` |
416331ca | 2555 | /// use serde::Deserialize; |
041b39d2 XL |
2556 | /// |
2557 | /// #[derive(Deserialize, Debug)] | |
2558 | /// struct User { | |
2559 | /// fingerprint: String, | |
2560 | /// location: String, | |
2561 | /// } | |
2562 | /// | |
2563 | /// fn main() { | |
2564 | /// // The type of `j` is `&str` | |
416331ca XL |
2565 | /// let j = " |
2566 | /// { | |
2567 | /// \"fingerprint\": \"0xF9BA143B95FF6D82\", | |
2568 | /// \"location\": \"Menlo Park, CA\" | |
2569 | /// }"; | |
041b39d2 XL |
2570 | /// |
2571 | /// let u: User = serde_json::from_str(j).unwrap(); | |
2572 | /// println!("{:#?}", u); | |
2573 | /// } | |
2574 | /// ``` | |
416331ca XL |
2575 | /// |
2576 | /// # Errors | |
2577 | /// | |
2578 | /// This conversion can fail if the structure of the input does not match the | |
2579 | /// structure expected by `T`, for example if `T` is a struct type but the input | |
2580 | /// contains something other than a JSON map. It can also fail if the structure | |
2581 | /// is correct but `T`'s implementation of `Deserialize` decides that something | |
2582 | /// is wrong with the data, for example required struct fields are missing from | |
2583 | /// the JSON map or some number is too big to fit in the expected primitive | |
2584 | /// type. | |
041b39d2 XL |
2585 | pub fn from_str<'a, T>(s: &'a str) -> Result<T> |
2586 | where | |
2587 | T: de::Deserialize<'a>, | |
7cac9316 XL |
2588 | { |
2589 | from_trait(read::StrRead::new(s)) | |
2590 | } |