serde_json/
de.rs

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