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