--- a/Cargo.lock
+++ b/Cargo.lock
@@ -133,24 +133,16 @@ dependencies = [
"log 0.3.9 (registry+https://github.com/rust-lang/crates.io-index)",
"slab 0.3.0 (registry+https://github.com/rust-lang/crates.io-index)",
"tokio-core 0.1.7 (registry+https://github.com/rust-lang/crates.io-index)",
"tokio-uds 0.1.7 (registry+https://github.com/rust-lang/crates.io-index)",
]
[[package]]
name = "base64"
-version = "0.5.2"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-dependencies = [
- "byteorder 1.2.1 (registry+https://github.com/rust-lang/crates.io-index)",
-]
-
-[[package]]
-name = "base64"
version = "0.6.0"
source = "registry+https://github.com/rust-lang/crates.io-index"
dependencies = [
"byteorder 1.2.1 (registry+https://github.com/rust-lang/crates.io-index)",
"safemem 0.2.0 (registry+https://github.com/rust-lang/crates.io-index)",
]
[[package]]
@@ -809,17 +801,17 @@ dependencies = [
"winapi 0.2.8 (registry+https://github.com/rust-lang/crates.io-index)",
"winapi-build 0.1.1 (registry+https://github.com/rust-lang/crates.io-index)",
]
[[package]]
name = "geckodriver"
version = "0.21.0"
dependencies = [
- "base64 0.5.2 (registry+https://github.com/rust-lang/crates.io-index)",
+ "base64 0.6.0 (registry+https://github.com/rust-lang/crates.io-index)",
"chrono 0.2.25 (registry+https://github.com/rust-lang/crates.io-index)",
"clap 2.31.2 (registry+https://github.com/rust-lang/crates.io-index)",
"hyper 0.10.13 (registry+https://github.com/rust-lang/crates.io-index)",
"lazy_static 1.0.1 (registry+https://github.com/rust-lang/crates.io-index)",
"log 0.4.2 (registry+https://github.com/rust-lang/crates.io-index)",
"mozprofile 0.3.0",
"mozrunner 0.7.0",
"mozversion 0.1.3",
@@ -1801,17 +1793,17 @@ source = "registry+https://github.com/ru
dependencies = [
"serde 1.0.66 (registry+https://github.com/rust-lang/crates.io-index)",
]
[[package]]
name = "rsdparsa"
version = "0.1.0"
dependencies = [
- "log 0.3.9 (registry+https://github.com/rust-lang/crates.io-index)",
+ "log 0.4.2 (registry+https://github.com/rust-lang/crates.io-index)",
"serde 1.0.66 (registry+https://github.com/rust-lang/crates.io-index)",
"serde_derive 1.0.66 (git+https://github.com/servo/serde?branch=deserialize_from_enums8)",
]
[[package]]
name = "rsdparsa_capi"
version = "0.1.0"
dependencies = [
@@ -2412,17 +2404,17 @@ dependencies = [
"same-file 1.0.2 (registry+https://github.com/rust-lang/crates.io-index)",
"winapi 0.3.4 (registry+https://github.com/rust-lang/crates.io-index)",
]
[[package]]
name = "webdriver"
version = "0.36.0"
dependencies = [
- "base64 0.5.2 (registry+https://github.com/rust-lang/crates.io-index)",
+ "base64 0.6.0 (registry+https://github.com/rust-lang/crates.io-index)",
"cookie 0.10.1 (registry+https://github.com/rust-lang/crates.io-index)",
"hyper 0.10.13 (registry+https://github.com/rust-lang/crates.io-index)",
"lazy_static 1.0.1 (registry+https://github.com/rust-lang/crates.io-index)",
"log 0.4.2 (registry+https://github.com/rust-lang/crates.io-index)",
"regex 1.0.0 (registry+https://github.com/rust-lang/crates.io-index)",
"serde 1.0.66 (registry+https://github.com/rust-lang/crates.io-index)",
"serde_derive 1.0.66 (git+https://github.com/servo/serde?branch=deserialize_from_enums8)",
"serde_json 1.0.22 (registry+https://github.com/rust-lang/crates.io-index)",
@@ -2634,17 +2626,16 @@ dependencies = [
"checksum ansi_term 0.11.0 (registry+https://github.com/rust-lang/crates.io-index)" = "ee49baf6cb617b853aa8d93bf420db2383fab46d314482ca2803b40d5fde979b"
"checksum app_units 0.7.0 (registry+https://github.com/rust-lang/crates.io-index)" = "9dadc668390b373e73e4abbfc1f07238b09a25858f2f39c06cebc6d8e141d774"
"checksum arrayref 0.3.4 (registry+https://github.com/rust-lang/crates.io-index)" = "0fd1479b7c29641adbd35ff3b5c293922d696a92f25c8c975da3e0acbc87258f"
"checksum arrayvec 0.4.6 (registry+https://github.com/rust-lang/crates.io-index)" = "2f0ef4a9820019a0c91d918918c93dc71d469f581a49b47ddc1d285d4270bbe2"
"checksum ascii-canvas 1.0.0 (registry+https://github.com/rust-lang/crates.io-index)" = "b385d69402821a1c254533a011a312531cbcc0e3e24f19bbb4747a5a2daf37e2"
"checksum atomic_refcell 0.1.0 (registry+https://github.com/rust-lang/crates.io-index)" = "fb2dcb6e6d35f20276943cc04bb98e538b348d525a04ac79c10021561d202f21"
"checksum atty 0.1.2 (registry+https://github.com/rust-lang/crates.io-index)" = "d0fd4c0631f06448cc45a6bbb3b710ebb7ff8ccb96a0800c994afe23a70d5df2"
"checksum atty 0.2.2 (registry+https://github.com/rust-lang/crates.io-index)" = "d912da0db7fa85514874458ca3651fe2cddace8d0b0505571dbdcd41ab490159"
-"checksum base64 0.5.2 (registry+https://github.com/rust-lang/crates.io-index)" = "30e93c03064e7590d0466209155251b90c22e37fab1daf2771582598b5827557"
"checksum base64 0.6.0 (registry+https://github.com/rust-lang/crates.io-index)" = "96434f987501f0ed4eb336a411e0631ecd1afa11574fe148587adc4ff96143c9"
"checksum binary-space-partition 0.1.2 (registry+https://github.com/rust-lang/crates.io-index)" = "88ceb0d16c4fd0e42876e298d7d3ce3780dd9ebdcbe4199816a32c77e08597ff"
"checksum bincode 1.0.0 (registry+https://github.com/rust-lang/crates.io-index)" = "bda13183df33055cbb84b847becce220d392df502ebe7a4a78d7021771ed94d0"
"checksum bindgen 0.37.4 (registry+https://github.com/rust-lang/crates.io-index)" = "1b25ab82877ea8fe6ce1ce1f8ac54361f0218bad900af9eb11803994bf67c221"
"checksum binjs_meta 0.3.8 (registry+https://github.com/rust-lang/crates.io-index)" = "fd7ca5635f1c6f94aaef7de76cb834c5920578355ce41dbcaf731b7ebe348518"
"checksum bit-set 0.4.0 (registry+https://github.com/rust-lang/crates.io-index)" = "d9bf6104718e80d7b26a68fdbacff3481cfc05df670821affc7e9cbc1884400c"
"checksum bit-vec 0.4.4 (registry+https://github.com/rust-lang/crates.io-index)" = "02b4ff8b16e6076c3e14220b39fbc1fabb6737522281a388998046859400895f"
"checksum bitflags 0.7.0 (registry+https://github.com/rust-lang/crates.io-index)" = "aad18937a628ec6abcd26d1489012cc0e18c21798210f491af69ded9b881106d"
deleted file mode 100644
--- a/third_party/rust/rustc-serialize/.cargo-checksum.json
+++ /dev/null
@@ -1,1 +0,0 @@
-{"files":{".travis.yml":"03dcea6dcd54625b42d91176e86718626dfd911744a343dee3edefa001e87dc5","Cargo.toml":"01199fa6ca6337a7513e9ef8951268b8882347e5affaa50e710ac4960d9c65e0","LICENSE-APACHE":"a60eea817514531668d7e00765731449fe14d059d3249e0bc93b36de45f759f2","LICENSE-MIT":"6485b8ed310d3f0340bf1ad1f47645069ce4069dcc6bb46c7d5c6faf41de1fdb","README.md":"0aebc3beb6fc32d6073582d5fea170761689a2c83cddb5436aa26e57b7d04e7b","appveyor.yml":"da991211b72fa6f231af7adb84c9fb72f5a9131d1c0a3d47b8ceffe5a82c8542","benches/base64.rs":"96f7d0c7d260362e41b8cefb4839f1e1b3c18c2f10344f6ccafac7c434f99ca9","benches/hex.rs":"057821307b4b7de02f2c267f9248457386035382916c5afe4b72d6f2e905062c","benches/json.rs":"659f2ae2e1ad5ed022fafce6418d17dfe09c3dcb3f054857dce0effc907da850","src/base64.rs":"57649c590c1fba643ff955910f1d4427feda43414bb0863cd279bea56c3ff178","src/collection_impls.rs":"8ae6bc0d61a4777d834c2b24fa987550cb13c570e1564f87ee32eceff3cb2d5b","src/hex.rs":"a2ba86cf47035b5d9cbf4adf8dc3e941d4e0a6ce1a61a29cbb14ea1fdabac6bb","src/json.rs":"75a788a46612c73bfd14af20fb48855dc8c930747c5255a288d2d09de25ea960","src/lib.rs":"a0e4a368a609f019434e7584f54448cf33ebf3e37e3fb1dd5537d300088184b1","src/serialize.rs":"7ddcc3c32843850e30d05b82a8cda8ae63ec0016e2b0bfbcc46a03ea3ea986e8"},"package":"dcf128d1287d2ea9d80910b5f1120d0b8eede3fbf1abe91c40d39ea7d51e6fda"}
\ No newline at end of file
deleted file mode 100644
--- a/third_party/rust/rustc-serialize/.travis.yml
+++ /dev/null
@@ -1,24 +0,0 @@
-language: rust
-rust:
- - 1.0.0
- - stable
- - beta
- - nightly
-sudo: false
-before_script:
- - pip install 'travis-cargo<0.2' --user && export PATH=$HOME/.local/bin:$PATH
-script:
- - cargo build --verbose
- - cargo test --verbose
- - cargo doc --no-deps
-after_success:
- - travis-cargo --only nightly doc-upload
-env:
- global:
- secure: "kJnqqAXRl0C7Afx0c8Y3vA6TAEZsxlasu7eIZMdCbNS4N1+Rwh0jNTa2jy2D3CQCrzW5OCefnkpkPTu8mADrAjedM4p/9X5UXZi0sgg2lzCgfGwrRzitTnyPDkdYidiu4QeC/r0WPC8lYZKHkJXYhF8bZgchB9ypnZ6LAHCcDkA="
-
-
-
-notifications:
- email:
- on_success: never
deleted file mode 100644
--- a/third_party/rust/rustc-serialize/Cargo.toml
+++ /dev/null
@@ -1,18 +0,0 @@
-[package]
-
-name = "rustc-serialize"
-version = "0.3.24"
-authors = ["The Rust Project Developers"]
-license = "MIT/Apache-2.0"
-readme = "README.md"
-repository = "https://github.com/rust-lang/rustc-serialize"
-homepage = "https://github.com/rust-lang/rustc-serialize"
-documentation = "https://doc.rust-lang.org/rustc-serialize"
-description = """
-Generic serialization/deserialization support corresponding to the
-`derive(RustcEncodable, RustcDecodable)` mode in the compiler. Also includes
-support for hex, base64, and json encoding and decoding.
-"""
-
-[dev-dependencies]
-rand = "0.3"
deleted file mode 100644
--- a/third_party/rust/rustc-serialize/README.md
+++ /dev/null
@@ -1,31 +0,0 @@
-# rustc-serialize
-
-> **NOTE**: This crate is deprecated in favor of [`serde`]. No new feature
-> development will happen in this crate, although bug fixes proposed through PRs
-> will still be merged. It is very highly recommended by the Rust Library Team
-> that you use [`serde`], not this crate.
-
-[`serde`]: https://serde.rs
-
-Serialization and deserialization support provided by the compiler in the form
-of `derive(RustcEncodable, RustcDecodable)`.
-
-[](https://travis-ci.org/rust-lang-nursery/rustc-serialize)
-[](https://ci.appveyor.com/project/alexcrichton/rustc-serialize)
-
-[Documentation](https://doc.rust-lang.org/rustc-serialize)
-
-## Usage
-
-Add this to your `Cargo.toml`:
-
-```toml
-[dependencies]
-rustc-serialize = "0.3"
-```
-
-and this to your crate root:
-
-```rust
-extern crate rustc_serialize;
-```
deleted file mode 100644
--- a/third_party/rust/rustc-serialize/appveyor.yml
+++ /dev/null
@@ -1,17 +0,0 @@
-environment:
- matrix:
- - TARGET: x86_64-pc-windows-msvc
- - TARGET: i686-pc-windows-msvc
- - TARGET: i686-pc-windows-gnu
-install:
- - ps: Start-FileDownload "https://static.rust-lang.org/dist/rust-nightly-${env:TARGET}.exe"
- - rust-nightly-%TARGET%.exe /VERYSILENT /NORESTART /DIR="C:\Program Files (x86)\Rust"
- - SET PATH=%PATH%;C:\Program Files (x86)\Rust\bin
- - SET PATH=%PATH%;C:\MinGW\bin
- - rustc -V
- - cargo -V
-
-build: false
-
-test_script:
- - cargo test --verbose
deleted file mode 100644
--- a/third_party/rust/rustc-serialize/benches/base64.rs
+++ /dev/null
@@ -1,48 +0,0 @@
-#![feature(test)]
-
-extern crate test;
-extern crate rustc_serialize;
-
-use rustc_serialize::base64::{FromBase64, ToBase64, STANDARD};
-use test::Bencher;
-
-#[bench]
-fn bench_to_base64(b: &mut Bencher) {
- let s = "イロハニホヘト チリヌルヲ ワカヨタレソ ツネナラム \
- ウヰノオクヤマ ケフコエテ アサキユメミシ ヱヒモセスン";
- b.iter(|| {
- s.as_bytes().to_base64(STANDARD);
- });
- b.bytes = s.len() as u64;
-}
-
-#[bench]
-fn bench_from_base64(b: &mut Bencher) {
- let s = "イロハニホヘト チリヌルヲ ワカヨタレソ ツネナラム \
- ウヰノオクヤマ ケフコエテ アサキユメミシ ヱヒモセスン";
- let sb = s.as_bytes().to_base64(STANDARD);
- b.iter(|| {
- sb.from_base64().unwrap();
- });
- b.bytes = sb.len() as u64;
-}
-
-
-#[bench]
-fn bench_to_base64_large(b: &mut Bencher) {
- let s: Vec<_> = (0..10000).map(|i| ((i as u32 * 12345) % 256) as u8).collect();
- b.iter(|| {
- s.to_base64(STANDARD);
- });
- b.bytes = s.len() as u64;
-}
-
-#[bench]
-fn bench_from_base64_large(b: &mut Bencher) {
- let s: Vec<_> = (0..10000).map(|i| ((i as u32 * 12345) % 256) as u8).collect();
- let sb = s.to_base64(STANDARD);
- b.iter(|| {
- sb.from_base64().unwrap();
- });
- b.bytes = sb.len() as u64;
-}
deleted file mode 100644
--- a/third_party/rust/rustc-serialize/benches/hex.rs
+++ /dev/null
@@ -1,28 +0,0 @@
-#![feature(test)]
-
-extern crate test;
-extern crate rustc_serialize;
-
-use test::Bencher;
-use rustc_serialize::hex::{FromHex, ToHex};
-
-#[bench]
-fn bench_to_hex(b: &mut Bencher) {
- let s = "イロハニホヘト チリヌルヲ ワカヨタレソ ツネナラム \
- ウヰノオクヤマ ケフコエテ アサキユメミシ ヱヒモセスン";
- b.iter(|| {
- s.as_bytes().to_hex();
- });
- b.bytes = s.len() as u64;
-}
-
-#[bench]
-fn bench_from_hex(b: &mut Bencher) {
- let s = "イロハニホヘト チリヌルヲ ワカヨタレソ ツネナラム \
- ウヰノオクヤマ ケフコエテ アサキユメミシ ヱヒモセスン";
- let sb = s.as_bytes().to_hex();
- b.iter(|| {
- sb.from_hex().unwrap();
- });
- b.bytes = sb.len() as u64;
-}
deleted file mode 100644
--- a/third_party/rust/rustc-serialize/benches/json.rs
+++ /dev/null
@@ -1,84 +0,0 @@
-#![feature(test)]
-
-extern crate test;
-extern crate rustc_serialize;
-
-use std::string;
-use rustc_serialize::json::{Json, Parser};
-use test::Bencher;
-
-#[bench]
-fn bench_streaming_small(b: &mut Bencher) {
- b.iter( || {
- let mut parser = Parser::new(
- r#"{
- "a": 1.0,
- "b": [
- true,
- "foo\nbar",
- { "c": {"d": null} }
- ]
- }"#.chars()
- );
- loop {
- match parser.next() {
- None => return,
- _ => {}
- }
- }
- });
-}
-#[bench]
-fn bench_small(b: &mut Bencher) {
- b.iter( || {
- let _ = Json::from_str(r#"{
- "a": 1.0,
- "b": [
- true,
- "foo\nbar",
- { "c": {"d": null} }
- ]
- }"#);
- });
-}
-
-#[bench]
-fn bench_decode_hex_escape(b: &mut Bencher) {
- let mut src = "\"".to_string();
- for _ in 0..10 {
- src.push_str("\\uF975\\uf9bc\\uF9A0\\uF9C4\\uF975\\uf9bc\\uF9A0\\uF9C4");
- }
- src.push_str("\"");
- b.iter( || {
- let _ = Json::from_str(&src);
- });
-}
-
-fn big_json() -> string::String {
- let mut src = "[\n".to_string();
- for _ in 0..500 {
- src.push_str(r#"{ "a": true, "b": null, "c":3.1415, "d": "Hello world", "e": \
- [1,2,3]},"#);
- }
- src.push_str("{}]");
- return src;
-}
-
-#[bench]
-fn bench_streaming_large(b: &mut Bencher) {
- let src = big_json();
- b.iter( || {
- let mut parser = Parser::new(src.chars());
- loop {
- match parser.next() {
- None => return,
- _ => {}
- }
- }
- });
-}
-#[bench]
-fn bench_large(b: &mut Bencher) {
- let src = big_json();
- b.iter( || { let _ = Json::from_str(&src); });
-}
deleted file mode 100644
--- a/third_party/rust/rustc-serialize/src/base64.rs
+++ /dev/null
@@ -1,489 +0,0 @@
-// Copyright 2012-2014 The Rust Project Developers. See the COPYRIGHT
-// file at the top-level directory of this distribution and at
-// http://rust-lang.org/COPYRIGHT.
-//
-// Licensed under the Apache License, Version 2.0 <LICENSE-APACHE or
-// http://www.apache.org/licenses/LICENSE-2.0> or the MIT license
-// <LICENSE-MIT or http://opensource.org/licenses/MIT>, at your
-// option. This file may not be copied, modified, or distributed
-// except according to those terms.
-//
-// ignore-lexer-test FIXME #15679
-
-//! Base64 binary-to-text encoding
-
-pub use self::FromBase64Error::*;
-pub use self::CharacterSet::*;
-
-use std::fmt;
-use std::error;
-
-/// Available encoding character sets
-#[derive(Clone, Copy, Debug)]
-pub enum CharacterSet {
- /// The standard character set (uses `+` and `/`)
- Standard,
- /// The URL safe character set (uses `-` and `_`)
- UrlSafe
-}
-
-/// Available newline types
-#[derive(Clone, Copy, Debug)]
-pub enum Newline {
- /// A linefeed (i.e. Unix-style newline)
- LF,
- /// A carriage return and a linefeed (i.e. Windows-style newline)
- CRLF
-}
-
-/// Contains configuration parameters for `to_base64`.
-#[derive(Clone, Copy, Debug)]
-pub struct Config {
- /// Character set to use
- pub char_set: CharacterSet,
- /// Newline to use
- pub newline: Newline,
- /// True to pad output with `=` characters
- pub pad: bool,
- /// `Some(len)` to wrap lines at `len`, `None` to disable line wrapping
- pub line_length: Option<usize>
-}
-
-/// Configuration for RFC 4648 standard base64 encoding
-pub static STANDARD: Config =
- Config {char_set: Standard, newline: Newline::CRLF, pad: true, line_length: None};
-
-/// Configuration for RFC 4648 base64url encoding
-pub static URL_SAFE: Config =
- Config {char_set: UrlSafe, newline: Newline::CRLF, pad: false, line_length: None};
-
-/// Configuration for RFC 2045 MIME base64 encoding
-pub static MIME: Config =
- Config {char_set: Standard, newline: Newline::CRLF, pad: true, line_length: Some(76)};
-
-static STANDARD_CHARS: &'static[u8] = b"ABCDEFGHIJKLMNOPQRSTUVWXYZ\
- abcdefghijklmnopqrstuvwxyz\
- 0123456789+/";
-
-static URLSAFE_CHARS: &'static[u8] = b"ABCDEFGHIJKLMNOPQRSTUVWXYZ\
- abcdefghijklmnopqrstuvwxyz\
- 0123456789-_";
-
-/// A trait for converting a value to base64 encoding.
-pub trait ToBase64 {
- /// Converts the value of `self` to a base64 value following the specified
- /// format configuration, returning the owned string.
- fn to_base64(&self, config: Config) -> String;
-}
-
-impl ToBase64 for [u8] {
- /// Turn a vector of `u8` bytes into a base64 string.
- ///
- /// # Example
- ///
- /// ```rust
- /// extern crate rustc_serialize;
- /// use rustc_serialize::base64::{ToBase64, STANDARD};
- ///
- /// fn main () {
- /// let str = [52,32].to_base64(STANDARD);
- /// println!("base 64 output: {:?}", str);
- /// }
- /// ```
- fn to_base64(&self, config: Config) -> String {
- let bytes = match config.char_set {
- Standard => STANDARD_CHARS,
- UrlSafe => URLSAFE_CHARS
- };
-
- let len = self.len();
- let newline = match config.newline {
- Newline::LF => "\n",
- Newline::CRLF => "\r\n",
- };
-
- // Preallocate memory.
- let mut prealloc_len = (len + 2) / 3 * 4;
- if let Some(line_length) = config.line_length {
- let num_lines = match prealloc_len {
- 0 => 0,
- n => (n - 1) / line_length
- };
- prealloc_len += num_lines * newline.bytes().count();
- }
-
- let mut out_bytes = vec![b'='; prealloc_len];
-
- // Deal with padding bytes
- let mod_len = len % 3;
-
- // Use iterators to reduce branching
- {
- let mut cur_length = 0;
-
- let mut s_in = self[..len - mod_len].iter().map(|&x| x as u32);
- let mut s_out = out_bytes.iter_mut();
-
- // Convenient shorthand
- let enc = |val| bytes[val as usize];
- let mut write = |val| *s_out.next().unwrap() = val;
-
- // Iterate though blocks of 4
- while let (Some(first), Some(second), Some(third)) =
- (s_in.next(), s_in.next(), s_in.next()) {
-
- // Line break if needed
- if let Some(line_length) = config.line_length {
- if cur_length >= line_length {
- for b in newline.bytes() { write(b) };
- cur_length = 0;
- }
- }
-
- let n = first << 16 | second << 8 | third;
-
- // This 24-bit number gets separated into four 6-bit numbers.
- write(enc((n >> 18) & 63));
- write(enc((n >> 12) & 63));
- write(enc((n >> 6 ) & 63));
- write(enc((n >> 0 ) & 63));
-
- cur_length += 4;
- }
-
- // Line break only needed if padding is required
- if mod_len != 0 {
- if let Some(line_length) = config.line_length {
- if cur_length >= line_length {
- for b in newline.bytes() { write(b) };
- }
- }
- }
-
- // Heh, would be cool if we knew this was exhaustive
- // (the dream of bounded integer types)
- match mod_len {
- 0 => (),
- 1 => {
- let n = (self[len-1] as u32) << 16;
- write(enc((n >> 18) & 63));
- write(enc((n >> 12) & 63));
- }
- 2 => {
- let n = (self[len-2] as u32) << 16 |
- (self[len-1] as u32) << 8;
- write(enc((n >> 18) & 63));
- write(enc((n >> 12) & 63));
- write(enc((n >> 6 ) & 63));
- }
- _ => panic!("Algebra is broken, please alert the math police")
- }
- }
-
- // We get padding for "free", so only have to drop it if unwanted.
- if !config.pad {
- while let Some(&b'=') = out_bytes.last() {
- out_bytes.pop();
- }
- }
-
- unsafe { String::from_utf8_unchecked(out_bytes) }
- }
-}
-
-impl<'a, T: ?Sized + ToBase64> ToBase64 for &'a T {
- fn to_base64(&self, config: Config) -> String {
- (**self).to_base64(config)
- }
-}
-
-/// A trait for converting from base64 encoded values.
-pub trait FromBase64 {
- /// Converts the value of `self`, interpreted as base64 encoded data, into
- /// an owned vector of bytes, returning the vector.
- fn from_base64(&self) -> Result<Vec<u8>, FromBase64Error>;
-}
-
-/// Errors that can occur when decoding a base64 encoded string
-#[derive(Clone, Copy)]
-pub enum FromBase64Error {
- /// The input contained a character not part of the base64 format
- InvalidBase64Byte(u8, usize),
- /// The input had an invalid length
- InvalidBase64Length,
-}
-
-impl fmt::Debug for FromBase64Error {
- fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
- match *self {
- InvalidBase64Byte(ch, idx) =>
- write!(f, "Invalid character '{}' at position {}", ch, idx),
- InvalidBase64Length => write!(f, "Invalid length"),
- }
- }
-}
-
-impl error::Error for FromBase64Error {
- fn description(&self) -> &str {
- match *self {
- InvalidBase64Byte(_, _) => "invalid character",
- InvalidBase64Length => "invalid length",
- }
- }
-}
-
-impl fmt::Display for FromBase64Error {
- fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
- fmt::Debug::fmt(&self, f)
- }
-}
-
-impl FromBase64 for str {
- /// Convert any base64 encoded string (literal, `@`, `&`, or `~`)
- /// to the byte values it encodes.
- ///
- /// You can use the `String::from_utf8` function to turn a `Vec<u8>` into a
- /// string with characters corresponding to those values.
- ///
- /// # Example
- ///
- /// This converts a string literal to base64 and back.
- ///
- /// ```rust
- /// extern crate rustc_serialize;
- /// use rustc_serialize::base64::{ToBase64, FromBase64, STANDARD};
- ///
- /// fn main () {
- /// let hello_str = b"Hello, World".to_base64(STANDARD);
- /// println!("base64 output: {}", hello_str);
- /// let res = hello_str.from_base64();
- /// if res.is_ok() {
- /// let opt_bytes = String::from_utf8(res.unwrap());
- /// if opt_bytes.is_ok() {
- /// println!("decoded from base64: {:?}", opt_bytes.unwrap());
- /// }
- /// }
- /// }
- /// ```
- #[inline]
- fn from_base64(&self) -> Result<Vec<u8>, FromBase64Error> {
- self.as_bytes().from_base64()
- }
-}
-
-impl FromBase64 for [u8] {
- fn from_base64(&self) -> Result<Vec<u8>, FromBase64Error> {
- let mut r = Vec::with_capacity(self.len());
- let mut buf: u32 = 0;
- let mut modulus = 0;
-
- let mut it = self.iter();
- for byte in it.by_ref() {
- let code = DECODE_TABLE[*byte as usize];
- if code >= SPECIAL_CODES_START {
- match code {
- NEWLINE_CODE => continue,
- EQUALS_CODE => break,
- INVALID_CODE => return Err(InvalidBase64Byte(
- *byte, (byte as *const _ as usize) - self.as_ptr() as usize)),
- _ => unreachable!(),
- }
- }
- buf = (buf | code as u32) << 6;
- modulus += 1;
- if modulus == 4 {
- modulus = 0;
- r.push((buf >> 22) as u8);
- r.push((buf >> 14) as u8);
- r.push((buf >> 6 ) as u8);
- }
- }
-
- for byte in it {
- match *byte {
- b'=' | b'\r' | b'\n' => continue,
- _ => return Err(InvalidBase64Byte(
- *byte, (byte as *const _ as usize) - self.as_ptr() as usize)),
- }
- }
-
- match modulus {
- 2 => {
- r.push((buf >> 10) as u8);
- }
- 3 => {
- r.push((buf >> 16) as u8);
- r.push((buf >> 8 ) as u8);
- }
- 0 => (),
- _ => return Err(InvalidBase64Length),
- }
-
- Ok(r)
- }
-}
-
-impl<'a, T: ?Sized + FromBase64> FromBase64 for &'a T {
- fn from_base64(&self) -> Result<Vec<u8>, FromBase64Error> {
- (**self).from_base64()
- }
-}
-
-/// Base64 decoding lookup table, generated using:
-///
-/// ```
-/// let mut ch = 0u8;
-/// for ch in 0..255 {
-/// let mut ch = ch as u8;
-/// let code = match ch {
-/// b'A'...b'Z' => ch - 0x41,
-/// b'a'...b'z' => ch - 0x47,
-/// b'0'...b'9' => ch + 0x04,
-/// b'+' | b'-' => 0x3E,
-/// b'/' | b'_' => 0x3F,
-/// b'=' => 0xFE,
-/// b'\r' | b'\n' => 0xFD,
-/// _ => 0xFF,
-/// };
-/// print!("0x{:02X}, ", code);
-/// if ch % 16 == 15 { println!(""); }
-/// else if ch == 0xFF { break; }
-/// ch += 1;
-/// }
-/// println!("");
-/// ```
-const DECODE_TABLE: [u8; 256] = [
- 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFD, 0xFF, 0xFF, 0xFD, 0xFF, 0xFF,
- 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF,
- 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0x3E, 0xFF, 0x3E, 0xFF, 0x3F,
- 0x34, 0x35, 0x36, 0x37, 0x38, 0x39, 0x3A, 0x3B, 0x3C, 0x3D, 0xFF, 0xFF, 0xFF, 0xFE, 0xFF, 0xFF,
- 0xFF, 0x00, 0x01, 0x02, 0x03, 0x04, 0x05, 0x06, 0x07, 0x08, 0x09, 0x0A, 0x0B, 0x0C, 0x0D, 0x0E,
- 0x0F, 0x10, 0x11, 0x12, 0x13, 0x14, 0x15, 0x16, 0x17, 0x18, 0x19, 0xFF, 0xFF, 0xFF, 0xFF, 0x3F,
- 0xFF, 0x1A, 0x1B, 0x1C, 0x1D, 0x1E, 0x1F, 0x20, 0x21, 0x22, 0x23, 0x24, 0x25, 0x26, 0x27, 0x28,
- 0x29, 0x2A, 0x2B, 0x2C, 0x2D, 0x2E, 0x2F, 0x30, 0x31, 0x32, 0x33, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF,
- 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF,
- 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF,
- 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF,
- 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF,
- 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF,
- 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF,
- 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF,
- 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF,
-];
-const INVALID_CODE: u8 = 0xFF;
-const EQUALS_CODE: u8 = 0xFE;
-const NEWLINE_CODE: u8 = 0xFD;
-const SPECIAL_CODES_START: u8 = NEWLINE_CODE;
-
-#[cfg(test)]
-mod tests {
- use base64::{Config, Newline, FromBase64, ToBase64, STANDARD, URL_SAFE};
-
- #[test]
- fn test_to_base64_basic() {
- assert_eq!("".as_bytes().to_base64(STANDARD), "");
- assert_eq!("f".as_bytes().to_base64(STANDARD), "Zg==");
- assert_eq!("fo".as_bytes().to_base64(STANDARD), "Zm8=");
- assert_eq!("foo".as_bytes().to_base64(STANDARD), "Zm9v");
- assert_eq!("foob".as_bytes().to_base64(STANDARD), "Zm9vYg==");
- assert_eq!("fooba".as_bytes().to_base64(STANDARD), "Zm9vYmE=");
- assert_eq!("foobar".as_bytes().to_base64(STANDARD), "Zm9vYmFy");
- }
-
- #[test]
- fn test_to_base64_crlf_line_break() {
- assert!(![0; 1000].to_base64(Config {line_length: None, ..STANDARD})
- .contains("\r\n"));
- assert_eq!(b"foobar".to_base64(Config {line_length: Some(4),
- ..STANDARD}),
- "Zm9v\r\nYmFy");
- }
-
- #[test]
- fn test_to_base64_lf_line_break() {
- assert!(![0; 1000].to_base64(Config {line_length: None,
- newline: Newline::LF,
- ..STANDARD})
- .contains("\n"));
- assert_eq!(b"foobar".to_base64(Config {line_length: Some(4),
- newline: Newline::LF,
- ..STANDARD}),
- "Zm9v\nYmFy");
- }
-
- #[test]
- fn test_to_base64_padding() {
- assert_eq!("f".as_bytes().to_base64(Config {pad: false, ..STANDARD}), "Zg");
- assert_eq!("fo".as_bytes().to_base64(Config {pad: false, ..STANDARD}), "Zm8");
- }
-
- #[test]
- fn test_to_base64_url_safe() {
- assert_eq!([251, 255].to_base64(URL_SAFE), "-_8");
- assert_eq!([251, 255].to_base64(STANDARD), "+/8=");
- }
-
- #[test]
- fn test_to_base64_empty_line_length() {
- [].to_base64(Config {line_length: Some(72), ..STANDARD});
- }
-
- #[test]
- fn test_from_base64_basic() {
- assert_eq!("".from_base64().unwrap(), b"");
- assert_eq!("Zg==".from_base64().unwrap(), b"f");
- assert_eq!("Zm8=".from_base64().unwrap(), b"fo");
- assert_eq!("Zm9v".from_base64().unwrap(), b"foo");
- assert_eq!("Zm9vYg==".from_base64().unwrap(), b"foob");
- assert_eq!("Zm9vYmE=".from_base64().unwrap(), b"fooba");
- assert_eq!("Zm9vYmFy".from_base64().unwrap(), b"foobar");
- }
-
- #[test]
- fn test_from_base64_bytes() {
- assert_eq!(b"Zm9vYmFy".from_base64().unwrap(), b"foobar");
- }
-
- #[test]
- fn test_from_base64_newlines() {
- assert_eq!("Zm9v\r\nYmFy".from_base64().unwrap(),
- b"foobar");
- assert_eq!("Zm9vYg==\r\n".from_base64().unwrap(),
- b"foob");
- assert_eq!("Zm9v\nYmFy".from_base64().unwrap(),
- b"foobar");
- assert_eq!("Zm9vYg==\n".from_base64().unwrap(),
- b"foob");
- }
-
- #[test]
- fn test_from_base64_urlsafe() {
- assert_eq!("-_8".from_base64().unwrap(), "+/8=".from_base64().unwrap());
- }
-
- #[test]
- fn test_from_base64_invalid_char() {
- assert!("Zm$=".from_base64().is_err());
- assert!("Zg==$".from_base64().is_err());
- }
-
- #[test]
- fn test_from_base64_invalid_padding() {
- assert!("Z===".from_base64().is_err());
- }
-
- #[test]
- fn test_base64_random() {
- use rand::{thread_rng, Rng};
-
- for _ in 0..1000 {
- let times = thread_rng().gen_range(1, 100);
- let v = thread_rng().gen_iter::<u8>().take(times)
- .collect::<Vec<_>>();
- assert_eq!(v.to_base64(STANDARD)
- .from_base64()
- .unwrap(),
- v);
- }
- }
-}
deleted file mode 100644
--- a/third_party/rust/rustc-serialize/src/collection_impls.rs
+++ /dev/null
@@ -1,186 +0,0 @@
-// Copyright 2014 The Rust Project Developers. See the COPYRIGHT
-// file at the top-level directory of this distribution and at
-// http://rust-lang.org/COPYRIGHT.
-//
-// Licensed under the Apache License, Version 2.0 <LICENSE-APACHE or
-// http://www.apache.org/licenses/LICENSE-2.0> or the MIT license
-// <LICENSE-MIT or http://opensource.org/licenses/MIT>, at your
-// option. This file may not be copied, modified, or distributed
-// except according to those terms.
-
-//! Implementations of serialization for structures found in libcollections
-
-use std::hash::Hash;
-
-use {Decodable, Encodable, Decoder, Encoder, cap_capacity};
-use std::collections::{LinkedList, VecDeque, BTreeMap, BTreeSet, HashMap, HashSet};
-
-impl<
- T: Encodable
-> Encodable for LinkedList<T> {
- fn encode<S: Encoder>(&self, s: &mut S) -> Result<(), S::Error> {
- s.emit_seq(self.len(), |s| {
- for (i, e) in self.iter().enumerate() {
- try!(s.emit_seq_elt(i, |s| e.encode(s)));
- }
- Ok(())
- })
- }
-}
-
-impl<T:Decodable> Decodable for LinkedList<T> {
- fn decode<D: Decoder>(d: &mut D) -> Result<LinkedList<T>, D::Error> {
- d.read_seq(|d, len| {
- let mut list = LinkedList::new();
- for i in 0..len {
- list.push_back(try!(d.read_seq_elt(i, |d| Decodable::decode(d))));
- }
- Ok(list)
- })
- }
-}
-
-impl<T: Encodable> Encodable for VecDeque<T> {
- fn encode<S: Encoder>(&self, s: &mut S) -> Result<(), S::Error> {
- s.emit_seq(self.len(), |s| {
- for (i, e) in self.iter().enumerate() {
- try!(s.emit_seq_elt(i, |s| e.encode(s)));
- }
- Ok(())
- })
- }
-}
-
-impl<T:Decodable> Decodable for VecDeque<T> {
- fn decode<D: Decoder>(d: &mut D) -> Result<VecDeque<T>, D::Error> {
- d.read_seq(|d, len| {
- let mut deque: VecDeque<T> = VecDeque::new();
- for i in 0..len {
- deque.push_back(try!(d.read_seq_elt(i, |d| Decodable::decode(d))));
- }
- Ok(deque)
- })
- }
-}
-
-impl<
- K: Encodable + Ord,
- V: Encodable
-> Encodable for BTreeMap<K, V> {
- fn encode<S: Encoder>(&self, e: &mut S) -> Result<(), S::Error> {
- e.emit_map(self.len(), |e| {
- let mut i = 0;
- for (key, val) in self.iter() {
- try!(e.emit_map_elt_key(i, |e| key.encode(e)));
- try!(e.emit_map_elt_val(i, |e| val.encode(e)));
- i += 1;
- }
- Ok(())
- })
- }
-}
-
-impl<
- K: Decodable + Ord,
- V: Decodable
-> Decodable for BTreeMap<K, V> {
- fn decode<D: Decoder>(d: &mut D) -> Result<BTreeMap<K, V>, D::Error> {
- d.read_map(|d, len| {
- let mut map = BTreeMap::new();
- for i in 0..len {
- let key = try!(d.read_map_elt_key(i, |d| Decodable::decode(d)));
- let val = try!(d.read_map_elt_val(i, |d| Decodable::decode(d)));
- map.insert(key, val);
- }
- Ok(map)
- })
- }
-}
-
-impl<
- T: Encodable + Ord
-> Encodable for BTreeSet<T> {
- fn encode<S: Encoder>(&self, s: &mut S) -> Result<(), S::Error> {
- s.emit_seq(self.len(), |s| {
- let mut i = 0;
- for e in self.iter() {
- try!(s.emit_seq_elt(i, |s| e.encode(s)));
- i += 1;
- }
- Ok(())
- })
- }
-}
-
-impl<
- T: Decodable + Ord
-> Decodable for BTreeSet<T> {
- fn decode<D: Decoder>(d: &mut D) -> Result<BTreeSet<T>, D::Error> {
- d.read_seq(|d, len| {
- let mut set = BTreeSet::new();
- for i in 0..len {
- set.insert(try!(d.read_seq_elt(i, |d| Decodable::decode(d))));
- }
- Ok(set)
- })
- }
-}
-
-impl<K, V> Encodable for HashMap<K, V>
- where K: Encodable + Hash + Eq,
- V: Encodable,
-{
- fn encode<E: Encoder>(&self, e: &mut E) -> Result<(), E::Error> {
- e.emit_map(self.len(), |e| {
- let mut i = 0;
- for (key, val) in self.iter() {
- try!(e.emit_map_elt_key(i, |e| key.encode(e)));
- try!(e.emit_map_elt_val(i, |e| val.encode(e)));
- i += 1;
- }
- Ok(())
- })
- }
-}
-
-impl<K, V> Decodable for HashMap<K, V>
- where K: Decodable + Hash + Eq,
- V: Decodable,
-{
- fn decode<D: Decoder>(d: &mut D) -> Result<HashMap<K, V>, D::Error> {
- d.read_map(|d, len| {
- let mut map = HashMap::with_capacity(cap_capacity::<(K, V)>(len));
- for i in 0..len {
- let key = try!(d.read_map_elt_key(i, |d| Decodable::decode(d)));
- let val = try!(d.read_map_elt_val(i, |d| Decodable::decode(d)));
- map.insert(key, val);
- }
- Ok(map)
- })
- }
-}
-
-impl<T> Encodable for HashSet<T> where T: Encodable + Hash + Eq {
- fn encode<E: Encoder>(&self, s: &mut E) -> Result<(), E::Error> {
- s.emit_seq(self.len(), |s| {
- let mut i = 0;
- for e in self.iter() {
- try!(s.emit_seq_elt(i, |s| e.encode(s)));
- i += 1;
- }
- Ok(())
- })
- }
-}
-
-impl<T> Decodable for HashSet<T> where T: Decodable + Hash + Eq, {
- fn decode<D: Decoder>(d: &mut D) -> Result<HashSet<T>, D::Error> {
- d.read_seq(|d, len| {
- let mut set = HashSet::with_capacity(cap_capacity::<T>(len));
- for i in 0..len {
- set.insert(try!(d.read_seq_elt(i, |d| Decodable::decode(d))));
- }
- Ok(set)
- })
- }
-}
deleted file mode 100644
--- a/third_party/rust/rustc-serialize/src/hex.rs
+++ /dev/null
@@ -1,221 +0,0 @@
-// Copyright 2013-2014 The Rust Project Developers. See the COPYRIGHT
-// file at the top-level directory of this distribution and at
-// http://rust-lang.org/COPYRIGHT.
-//
-// Licensed under the Apache License, Version 2.0 <LICENSE-APACHE or
-// http://www.apache.org/licenses/LICENSE-2.0> or the MIT license
-// <LICENSE-MIT or http://opensource.org/licenses/MIT>, at your
-// option. This file may not be copied, modified, or distributed
-// except according to those terms.
-//
-// ignore-lexer-test FIXME #15679
-
-//! Hex binary-to-text encoding
-
-pub use self::FromHexError::*;
-
-use std::fmt;
-use std::error;
-
-/// A trait for converting a value to hexadecimal encoding
-pub trait ToHex {
- /// Converts the value of `self` to a hex value, returning the owned
- /// string.
- fn to_hex(&self) -> String;
-}
-
-static CHARS: &'static[u8] = b"0123456789abcdef";
-
-impl ToHex for [u8] {
- /// Turn a vector of `u8` bytes into a hexadecimal string.
- ///
- /// # Example
- ///
- /// ```rust
- /// extern crate rustc_serialize;
- /// use rustc_serialize::hex::ToHex;
- ///
- /// fn main () {
- /// let str = [52,32].to_hex();
- /// println!("{}", str);
- /// }
- /// ```
- fn to_hex(&self) -> String {
- let mut v = Vec::with_capacity(self.len() * 2);
- for &byte in self.iter() {
- v.push(CHARS[(byte >> 4) as usize]);
- v.push(CHARS[(byte & 0xf) as usize]);
- }
-
- unsafe {
- String::from_utf8_unchecked(v)
- }
- }
-}
-
-impl<'a, T: ?Sized + ToHex> ToHex for &'a T {
- fn to_hex(&self) -> String {
- (**self).to_hex()
- }
-}
-
-/// A trait for converting hexadecimal encoded values
-pub trait FromHex {
- /// Converts the value of `self`, interpreted as hexadecimal encoded data,
- /// into an owned vector of bytes, returning the vector.
- fn from_hex(&self) -> Result<Vec<u8>, FromHexError>;
-}
-
-/// Errors that can occur when decoding a hex encoded string
-#[derive(Clone, Copy)]
-pub enum FromHexError {
- /// The input contained a character not part of the hex format
- InvalidHexCharacter(char, usize),
- /// The input had an invalid length
- InvalidHexLength,
-}
-
-impl fmt::Debug for FromHexError {
- fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
- match *self {
- InvalidHexCharacter(ch, idx) =>
- write!(f, "Invalid character '{}' at position {}", ch, idx),
- InvalidHexLength => write!(f, "Invalid input length"),
- }
- }
-}
-
-impl error::Error for FromHexError {
- fn description(&self) -> &str {
- match *self {
- InvalidHexCharacter(_, _) => "invalid character",
- InvalidHexLength => "invalid length",
- }
- }
-}
-
-impl fmt::Display for FromHexError {
- fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
- fmt::Debug::fmt(&self, f)
- }
-}
-
-impl FromHex for str {
- /// Convert any hexadecimal encoded string (literal, `@`, `&`, or `~`)
- /// to the byte values it encodes.
- ///
- /// You can use the `String::from_utf8` function to turn a
- /// `Vec<u8>` into a string with characters corresponding to those values.
- ///
- /// # Example
- ///
- /// This converts a string literal to hexadecimal and back.
- ///
- /// ```rust
- /// extern crate rustc_serialize;
- /// use rustc_serialize::hex::{FromHex, ToHex};
- ///
- /// fn main () {
- /// let hello_str = "Hello, World".as_bytes().to_hex();
- /// println!("{}", hello_str);
- /// let bytes = hello_str.from_hex().unwrap();
- /// println!("{:?}", bytes);
- /// let result_str = String::from_utf8(bytes).unwrap();
- /// println!("{}", result_str);
- /// }
- /// ```
- fn from_hex(&self) -> Result<Vec<u8>, FromHexError> {
- // This may be an overestimate if there is any whitespace
- let mut b = Vec::with_capacity(self.len() / 2);
- let mut modulus = 0;
- let mut buf = 0;
-
- for (idx, byte) in self.bytes().enumerate() {
- buf <<= 4;
-
- match byte {
- b'A'...b'F' => buf |= byte - b'A' + 10,
- b'a'...b'f' => buf |= byte - b'a' + 10,
- b'0'...b'9' => buf |= byte - b'0',
- b' '|b'\r'|b'\n'|b'\t' => {
- buf >>= 4;
- continue
- }
- _ => {
- let ch = self[idx..].chars().next().unwrap();
- return Err(InvalidHexCharacter(ch, idx))
- }
- }
-
- modulus += 1;
- if modulus == 2 {
- modulus = 0;
- b.push(buf);
- }
- }
-
- match modulus {
- 0 => Ok(b.into_iter().collect()),
- _ => Err(InvalidHexLength),
- }
- }
-}
-
-impl<'a, T: ?Sized + FromHex> FromHex for &'a T {
- fn from_hex(&self) -> Result<Vec<u8>, FromHexError> {
- (**self).from_hex()
- }
-}
-
-#[cfg(test)]
-mod tests {
- use hex::{FromHex, ToHex};
-
- #[test]
- pub fn test_to_hex() {
- assert_eq!("foobar".as_bytes().to_hex(), "666f6f626172");
- }
-
- #[test]
- pub fn test_from_hex_okay() {
- assert_eq!("666f6f626172".from_hex().unwrap(),
- b"foobar");
- assert_eq!("666F6F626172".from_hex().unwrap(),
- b"foobar");
- }
-
- #[test]
- pub fn test_from_hex_odd_len() {
- assert!("666".from_hex().is_err());
- assert!("66 6".from_hex().is_err());
- }
-
- #[test]
- pub fn test_from_hex_invalid_char() {
- assert!("66y6".from_hex().is_err());
- }
-
- #[test]
- pub fn test_from_hex_ignores_whitespace() {
- assert_eq!("666f 6f6\r\n26172 ".from_hex().unwrap(),
- b"foobar");
- }
-
- #[test]
- pub fn test_to_hex_all_bytes() {
- for i in 0..256 {
- assert_eq!([i as u8].to_hex(), format!("{:02x}", i));
- }
- }
-
- #[test]
- pub fn test_from_hex_all_bytes() {
- for i in 0..256 {
- let ii: &[u8] = &[i as u8];
- assert_eq!(format!("{:02x}", i).from_hex().unwrap(),
- ii);
- assert_eq!(format!("{:02X}", i).from_hex().unwrap(),
- ii);
- }
- }
-}
deleted file mode 100644
--- a/third_party/rust/rustc-serialize/src/json.rs
+++ /dev/null
@@ -1,3999 +0,0 @@
-// Copyright 2012-2014 The Rust Project Developers. See the COPYRIGHT
-// file at the top-level directory of this distribution and at
-// http://rust-lang.org/COPYRIGHT.
-//
-// Licensed under the Apache License, Version 2.0 <LICENSE-APACHE or
-// http://www.apache.org/licenses/LICENSE-2.0> or the MIT license
-// <LICENSE-MIT or http://opensource.org/licenses/MIT>, at your
-// option. This file may not be copied, modified, or distributed
-// except according to those terms.
-
-// Rust JSON serialization library
-// Copyright (c) 2011 Google Inc.
-
-//! JSON parsing and serialization
-//!
-//! # What is JSON?
-//!
-//! JSON (JavaScript Object Notation) is a way to write data in Javascript.
-//! Like XML, it allows encoding structured data in a text format that can be
-//! easily read by humans. Its simple syntax and native compatibility with
-//! JavaScript have made it a widely used format.
-//!
-//! Data types that can be encoded are JavaScript types (see the `Json` enum
-//! for more details):
-//!
-//! * `I64`: equivalent to rust's `i64`
-//! * `U64`: equivalent to rust's `u64`
-//! * `F64`: equivalent to rust's `f64`
-//! * `Boolean`: equivalent to rust's `bool`
-//! * `String`: equivalent to rust's `String`
-//! * `Array`: equivalent to rust's `Vec<T>`, but also allowing objects of
-//! different types in the
-//! same array
-//! * `Object`: equivalent to rust's `BTreeMap<String, json::Json>`
-//! * `Null`
-//!
-//! An object is a series of string keys mapping to values, in `"key": value`
-//! format. Arrays are enclosed in square brackets ([ ... ]) and objects in
-//! curly brackets ({ ... }). A simple JSON document encoding a person,
-//! their age, address and phone numbers could look like
-//!
-//! ```ignore
-//! {
-//! "FirstName": "John",
-//! "LastName": "Doe",
-//! "Age": 43,
-//! "Address": {
-//! "Street": "Downing Street 10",
-//! "City": "London",
-//! "Country": "Great Britain"
-//! },
-//! "PhoneNumbers": [
-//! "+44 1234567",
-//! "+44 2345678"
-//! ]
-//! }
-//! ```
-//!
-//! # Rust Type-based Encoding and Decoding
-//!
-//! Rust provides a mechanism for low boilerplate encoding & decoding of values
-//! to and from JSON via the serialization API. To be able to encode a piece
-//! of data, it must implement the `rustc_serialize::Encodable` trait. To be
-//! able to decode a piece of data, it must implement the
-//! `rustc_serialize::Decodable` trait. The Rust compiler provides an
-//! annotation to automatically generate the code for these traits:
-//! `#[derive(RustcDecodable, RustcEncodable)]`
-//!
-//! The JSON API provides an enum `json::Json` and a trait `ToJson` to encode
-//! objects. The `ToJson` trait provides a `to_json` method to convert an
-//! object into a `json::Json` value. A `json::Json` value can be encoded as a
-//! string or buffer using the functions described above. You can also use the
-//! `json::Encoder` object, which implements the `Encoder` trait.
-//!
-//! When using `ToJson`, the `Encodable` trait implementation is not
-//! mandatory.
-//!
-//! # Examples of use
-//!
-//! ## Using Autoserialization
-//!
-//! Create a struct called `TestStruct` and serialize and deserialize it to and
-//! from JSON using the serialization API, using the derived serialization code.
-//!
-//! ```rust
-//! extern crate rustc_serialize;
-//! use rustc_serialize::json;
-//!
-//! // Automatically generate `RustcDecodable` and `RustcEncodable` trait
-//! // implementations
-//! #[derive(RustcDecodable, RustcEncodable)]
-//! pub struct TestStruct {
-//! data_int: u8,
-//! data_str: String,
-//! data_vector: Vec<u8>,
-//! }
-//!
-//! fn main() {
-//! let object = TestStruct {
-//! data_int: 1,
-//! data_str: "homura".to_string(),
-//! data_vector: vec![2,3,4,5],
-//! };
-//!
-//! // Serialize using `json::encode`
-//! let encoded = json::encode(&object).unwrap();
-//!
-//! // Deserialize using `json::decode`
-//! let decoded: TestStruct = json::decode(&encoded).unwrap();
-//! }
-//! ```
-//!
-//! ## Using the `ToJson` trait
-//!
-//! The examples below use the `ToJson` trait to generate the JSON string,
-//! which is required for custom mappings.
-//!
-//! ### Simple example of `ToJson` usage
-//!
-//! ```rust
-//! extern crate rustc_serialize;
-//! use rustc_serialize::json::{self, ToJson, Json};
-//!
-//! // A custom data structure
-//! struct ComplexNum {
-//! a: f64,
-//! b: f64,
-//! }
-//!
-//! // JSON value representation
-//! impl ToJson for ComplexNum {
-//! fn to_json(&self) -> Json {
-//! Json::String(format!("{}+{}i", self.a, self.b))
-//! }
-//! }
-//!
-//! // Only generate `RustcEncodable` trait implementation
-//! #[derive(RustcEncodable)]
-//! pub struct ComplexNumRecord {
-//! uid: u8,
-//! dsc: String,
-//! val: Json,
-//! }
-//!
-//! fn main() {
-//! let num = ComplexNum { a: 0.0001, b: 12.539 };
-//! let data: String = json::encode(&ComplexNumRecord{
-//! uid: 1,
-//! dsc: "test".to_string(),
-//! val: num.to_json(),
-//! }).unwrap();
-//! println!("data: {}", data);
-//! // data: {"uid":1,"dsc":"test","val":"0.0001+12.539i"};
-//! }
-//! ```
-//!
-//! ### Verbose example of `ToJson` usage
-//!
-//! ```rust
-//! extern crate rustc_serialize;
-//! use std::collections::BTreeMap;
-//! use rustc_serialize::json::{self, Json, ToJson};
-//!
-//! // Only generate `Decodable` trait implementation
-//! #[derive(RustcDecodable)]
-//! pub struct TestStruct {
-//! data_int: u8,
-//! data_str: String,
-//! data_vector: Vec<u8>,
-//! }
-//!
-//! // Specify encoding method manually
-//! impl ToJson for TestStruct {
-//! fn to_json(&self) -> Json {
-//! let mut d = BTreeMap::new();
-//! // All standard types implement `to_json()`, so use it
-//! d.insert("data_int".to_string(), self.data_int.to_json());
-//! d.insert("data_str".to_string(), self.data_str.to_json());
-//! d.insert("data_vector".to_string(), self.data_vector.to_json());
-//! Json::Object(d)
-//! }
-//! }
-//!
-//! fn main() {
-//! // Serialize using `ToJson`
-//! let input_data = TestStruct {
-//! data_int: 1,
-//! data_str: "madoka".to_string(),
-//! data_vector: vec![2,3,4,5],
-//! };
-//! let json_obj: Json = input_data.to_json();
-//! let json_str: String = json_obj.to_string();
-//!
-//! // Deserialize like before
-//! let decoded: TestStruct = json::decode(&json_str).unwrap();
-//! }
-//! ```
-//!
-//! ## Parsing a `str` to `Json` and reading the result
-//!
-//! ```rust
-//! extern crate rustc_serialize;
-//! use rustc_serialize::json::Json;
-//!
-//! fn main() {
-//! let data = Json::from_str("{\"foo\": 13, \"bar\": \"baz\"}").unwrap();
-//! println!("data: {}", data);
-//! // data: {"bar":"baz","foo":13}
-//! println!("object? {}", data.is_object());
-//! // object? true
-//!
-//! let obj = data.as_object().unwrap();
-//! let foo = obj.get("foo").unwrap();
-//!
-//! println!("array? {:?}", foo.as_array());
-//! // array? None
-//! println!("u64? {:?}", foo.as_u64());
-//! // u64? Some(13u64)
-//!
-//! for (key, value) in obj.iter() {
-//! println!("{}: {}", key, match *value {
-//! Json::U64(v) => format!("{} (u64)", v),
-//! Json::String(ref v) => format!("{} (string)", v),
-//! _ => format!("other")
-//! });
-//! }
-//! // bar: baz (string)
-//! // foo: 13 (u64)
-//! }
-//! ```
-//!
-//! # The status of this library
-//!
-//! While this library is the standard way of working with JSON in Rust,
-//! there is a next-generation library called Serde that's in the works (it's
-//! faster, overcomes some design limitations of rustc-serialize and has more
-//! features). You might consider using it when starting a new project or
-//! evaluating Rust JSON performance.
-
-use self::JsonEvent::*;
-use self::ErrorCode::*;
-use self::ParserError::*;
-use self::DecoderError::*;
-use self::ParserState::*;
-use self::InternalStackElement::*;
-
-use std::collections::{HashMap, BTreeMap};
-use std::error::Error as StdError;
-use std::i64;
-use std::io::prelude::*;
-use std::mem::swap;
-use std::ops::Index;
-use std::str::FromStr;
-use std::string;
-use std::{char, f64, fmt, io, str};
-
-use Encodable;
-
-/// Represents a json value
-#[derive(Clone, PartialEq, PartialOrd, Debug)]
-pub enum Json {
- I64(i64),
- U64(u64),
- F64(f64),
- String(string::String),
- Boolean(bool),
- Array(self::Array),
- Object(self::Object),
- Null,
-}
-
-pub type Array = Vec<Json>;
-pub type Object = BTreeMap<string::String, Json>;
-
-pub struct PrettyJson<'a> { inner: &'a Json }
-
-pub struct AsJson<'a, T: 'a> { inner: &'a T }
-pub struct AsPrettyJson<'a, T: 'a> { inner: &'a T, indent: Option<u32> }
-
-/// The errors that can arise while parsing a JSON stream.
-#[derive(Clone, Copy, PartialEq)]
-pub enum ErrorCode {
- InvalidSyntax,
- InvalidNumber,
- EOFWhileParsingObject,
- EOFWhileParsingArray,
- EOFWhileParsingValue,
- EOFWhileParsingString,
- KeyMustBeAString,
- ExpectedColon,
- TrailingCharacters,
- TrailingComma,
- InvalidEscape,
- InvalidUnicodeCodePoint,
- LoneLeadingSurrogateInHexEscape,
- UnexpectedEndOfHexEscape,
- UnrecognizedHex,
- NotFourDigit,
- ControlCharacterInString,
- NotUtf8,
-}
-
-#[derive(Debug)]
-pub enum ParserError {
- /// msg, line, col
- SyntaxError(ErrorCode, usize, usize),
- IoError(io::Error),
-}
-
-impl PartialEq for ParserError {
- fn eq(&self, other: &ParserError) -> bool {
- match (self, other) {
- (&SyntaxError(msg0, line0, col0), &SyntaxError(msg1, line1, col1)) =>
- msg0 == msg1 && line0 == line1 && col0 == col1,
- (&IoError(_), _) => false,
- (_, &IoError(_)) => false,
- }
- }
-}
-
-// Builder and Parser have the same errors.
-pub type BuilderError = ParserError;
-
-#[derive(PartialEq, Debug)]
-pub enum DecoderError {
- ParseError(ParserError),
- ExpectedError(string::String, string::String),
- MissingFieldError(string::String),
- UnknownVariantError(string::String),
- ApplicationError(string::String),
- EOF,
-}
-
-#[derive(Copy, Debug)]
-pub enum EncoderError {
- FmtError(fmt::Error),
- BadHashmapKey,
-}
-
-impl PartialEq for EncoderError {
- fn eq(&self, other: &EncoderError) -> bool {
- match (*self, *other) {
- (EncoderError::FmtError(_), EncoderError::FmtError(_)) => true,
- (EncoderError::BadHashmapKey, EncoderError::BadHashmapKey) => true,
- _ => false,
- }
- }
-}
-
-impl Clone for EncoderError {
- fn clone(&self) -> Self { *self }
-}
-
-/// Returns a readable error string for a given error code.
-pub fn error_str(error: ErrorCode) -> &'static str {
- match error {
- InvalidSyntax => "invalid syntax",
- InvalidNumber => "invalid number",
- EOFWhileParsingObject => "EOF While parsing object",
- EOFWhileParsingArray => "EOF While parsing array",
- EOFWhileParsingValue => "EOF While parsing value",
- EOFWhileParsingString => "EOF While parsing string",
- KeyMustBeAString => "key must be a string",
- ExpectedColon => "expected `:`",
- TrailingCharacters => "trailing characters",
- TrailingComma => "trailing comma",
- InvalidEscape => "invalid escape",
- UnrecognizedHex => "invalid \\u{ esc}ape (unrecognized hex)",
- NotFourDigit => "invalid \\u{ esc}ape (not four digits)",
- ControlCharacterInString => "unescaped control character in string",
- NotUtf8 => "contents not utf-8",
- InvalidUnicodeCodePoint => "invalid Unicode code point",
- LoneLeadingSurrogateInHexEscape => "lone leading surrogate in hex escape",
- UnexpectedEndOfHexEscape => "unexpected end of hex escape",
- }
-}
-
-/// Shortcut function to decode a JSON `&str` into an object
-pub fn decode<T: ::Decodable>(s: &str) -> DecodeResult<T> {
- let json = match Json::from_str(s) {
- Ok(x) => x,
- Err(e) => return Err(ParseError(e))
- };
-
- let mut decoder = Decoder::new(json);
- ::Decodable::decode(&mut decoder)
-}
-
-/// Shortcut function to encode a `T` into a JSON `String`
-pub fn encode<T: ::Encodable>(object: &T) -> EncodeResult<string::String> {
- let mut s = String::new();
- {
- let mut encoder = Encoder::new(&mut s);
- try!(object.encode(&mut encoder));
- }
- Ok(s)
-}
-
-impl fmt::Debug for ErrorCode {
- fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
- error_str(*self).fmt(f)
- }
-}
-
-impl StdError for DecoderError {
- fn description(&self) -> &str { "decoder error" }
- fn cause(&self) -> Option<&StdError> {
- match *self {
- DecoderError::ParseError(ref e) => Some(e),
- _ => None,
- }
- }
-}
-
-impl fmt::Display for DecoderError {
- fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
- fmt::Debug::fmt(&self, f)
- }
-}
-
-impl From<ParserError> for DecoderError {
- fn from(err: ParserError) -> DecoderError {
- ParseError(From::from(err))
- }
-}
-
-impl StdError for ParserError {
- fn description(&self) -> &str { "failed to parse json" }
-}
-
-impl fmt::Display for ParserError {
- fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
- fmt::Debug::fmt(&self, f)
- }
-}
-
-impl From<io::Error> for ParserError {
- fn from(err: io::Error) -> ParserError {
- IoError(err)
- }
-}
-
-impl StdError for EncoderError {
- fn description(&self) -> &str { "encoder error" }
-}
-
-impl fmt::Display for EncoderError {
- fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
- fmt::Debug::fmt(&self, f)
- }
-}
-
-impl From<fmt::Error> for EncoderError {
- fn from(err: fmt::Error) -> EncoderError { EncoderError::FmtError(err) }
-}
-
-pub type EncodeResult<T> = Result<T, EncoderError>;
-pub type DecodeResult<T> = Result<T, DecoderError>;
-
-fn escape_str(wr: &mut fmt::Write, v: &str) -> EncodeResult<()> {
- try!(wr.write_str("\""));
-
- let mut start = 0;
-
- for (i, byte) in v.bytes().enumerate() {
- let escaped = match byte {
- b'"' => "\\\"",
- b'\\' => "\\\\",
- b'\x00' => "\\u0000",
- b'\x01' => "\\u0001",
- b'\x02' => "\\u0002",
- b'\x03' => "\\u0003",
- b'\x04' => "\\u0004",
- b'\x05' => "\\u0005",
- b'\x06' => "\\u0006",
- b'\x07' => "\\u0007",
- b'\x08' => "\\b",
- b'\t' => "\\t",
- b'\n' => "\\n",
- b'\x0b' => "\\u000b",
- b'\x0c' => "\\f",
- b'\r' => "\\r",
- b'\x0e' => "\\u000e",
- b'\x0f' => "\\u000f",
- b'\x10' => "\\u0010",
- b'\x11' => "\\u0011",
- b'\x12' => "\\u0012",
- b'\x13' => "\\u0013",
- b'\x14' => "\\u0014",
- b'\x15' => "\\u0015",
- b'\x16' => "\\u0016",
- b'\x17' => "\\u0017",
- b'\x18' => "\\u0018",
- b'\x19' => "\\u0019",
- b'\x1a' => "\\u001a",
- b'\x1b' => "\\u001b",
- b'\x1c' => "\\u001c",
- b'\x1d' => "\\u001d",
- b'\x1e' => "\\u001e",
- b'\x1f' => "\\u001f",
- b'\x7f' => "\\u007f",
- _ => { continue; }
- };
-
- if start < i {
- try!(wr.write_str(&v[start..i]));
- }
-
- try!(wr.write_str(escaped));
-
- start = i + 1;
- }
-
- if start != v.len() {
- try!(wr.write_str(&v[start..]));
- }
-
- try!(wr.write_str("\""));
- Ok(())
-}
-
-fn escape_char(writer: &mut fmt::Write, v: char) -> EncodeResult<()> {
- let mut buf = [0; 4];
- let _ = write!(&mut &mut buf[..], "{}", v);
- let buf = unsafe { str::from_utf8_unchecked(&buf[..v.len_utf8()]) };
- escape_str(writer, buf)
-}
-
-fn spaces(wr: &mut fmt::Write, n: u32) -> EncodeResult<()> {
- let mut n = n as usize;
- const BUF: &'static str = " ";
-
- while n >= BUF.len() {
- try!(wr.write_str(BUF));
- n -= BUF.len();
- }
-
- if n > 0 {
- try!(wr.write_str(&BUF[..n]));
- }
- Ok(())
-}
-
-fn fmt_number_or_null(v: f64) -> string::String {
- use std::num::FpCategory::{Nan, Infinite};
-
- match v.classify() {
- Nan | Infinite => "null".to_string(),
- _ => {
- let s = v.to_string();
- if s.contains(".") {s} else {s + ".0"}
- }
- }
-}
-
-macro_rules! emit_enquoted_if_mapkey {
- ($enc:ident,$e:expr) => {
- if $enc.is_emitting_map_key {
- try!(write!($enc.writer, "\"{}\"", $e));
- Ok(())
- } else {
- try!(write!($enc.writer, "{}", $e));
- Ok(())
- }
- }
-}
-
-enum EncodingFormat {
- Compact,
- Pretty {
- curr_indent: u32,
- indent: u32
- }
-}
-
-/// A structure for implementing serialization to JSON.
-pub struct Encoder<'a> {
- writer: &'a mut (fmt::Write+'a),
- format : EncodingFormat,
- is_emitting_map_key: bool,
-}
-
-impl<'a> Encoder<'a> {
- /// Creates a new encoder whose output will be written in human-readable
- /// JSON to the specified writer
- pub fn new_pretty(writer: &'a mut fmt::Write) -> Encoder<'a> {
- Encoder {
- writer: writer,
- format: EncodingFormat::Pretty {
- curr_indent: 0,
- indent: 2,
- },
- is_emitting_map_key: false,
- }
- }
-
- /// Creates a new encoder whose output will be written in compact
- /// JSON to the specified writer
- pub fn new(writer: &'a mut fmt::Write) -> Encoder<'a> {
- Encoder {
- writer: writer,
- format: EncodingFormat::Compact,
- is_emitting_map_key: false,
- }
- }
-
- /// Set the number of spaces to indent for each level.
- /// This is safe to set during encoding.
- pub fn set_indent(&mut self, new_indent: u32) -> Result<(), ()> {
- if let EncodingFormat::Pretty{ref mut curr_indent, ref mut indent} = self.format {
- // self.indent very well could be 0 so we need to use checked division.
- let level = curr_indent.checked_div(*indent).unwrap_or(0);
- *indent = new_indent;
- *curr_indent = level * *indent;
- Ok(())
- } else {
- Err(())
- }
- }
-}
-
-impl<'a> ::Encoder for Encoder<'a> {
- type Error = EncoderError;
-
- fn emit_nil(&mut self) -> EncodeResult<()> {
- if self.is_emitting_map_key { return Err(EncoderError::BadHashmapKey); }
- try!(write!(self.writer, "null"));
- Ok(())
- }
-
- fn emit_usize(&mut self, v: usize) -> EncodeResult<()> { emit_enquoted_if_mapkey!(self, v) }
- fn emit_u64(&mut self, v: u64) -> EncodeResult<()> { emit_enquoted_if_mapkey!(self, v) }
- fn emit_u32(&mut self, v: u32) -> EncodeResult<()> { emit_enquoted_if_mapkey!(self, v) }
- fn emit_u16(&mut self, v: u16) -> EncodeResult<()> { emit_enquoted_if_mapkey!(self, v) }
- fn emit_u8(&mut self, v: u8) -> EncodeResult<()> { emit_enquoted_if_mapkey!(self, v) }
-
- fn emit_isize(&mut self, v: isize) -> EncodeResult<()> { emit_enquoted_if_mapkey!(self, v) }
- fn emit_i64(&mut self, v: i64) -> EncodeResult<()> { emit_enquoted_if_mapkey!(self, v) }
- fn emit_i32(&mut self, v: i32) -> EncodeResult<()> { emit_enquoted_if_mapkey!(self, v) }
- fn emit_i16(&mut self, v: i16) -> EncodeResult<()> { emit_enquoted_if_mapkey!(self, v) }
- fn emit_i8(&mut self, v: i8) -> EncodeResult<()> { emit_enquoted_if_mapkey!(self, v) }
-
- fn emit_bool(&mut self, v: bool) -> EncodeResult<()> {
- if self.is_emitting_map_key { return Err(EncoderError::BadHashmapKey); }
- if v {
- try!(write!(self.writer, "true"));
- } else {
- try!(write!(self.writer, "false"));
- }
- Ok(())
- }
-
- fn emit_f64(&mut self, v: f64) -> EncodeResult<()> {
- emit_enquoted_if_mapkey!(self, fmt_number_or_null(v))
- }
- fn emit_f32(&mut self, v: f32) -> EncodeResult<()> {
- self.emit_f64(v as f64)
- }
-
- fn emit_char(&mut self, v: char) -> EncodeResult<()> {
- escape_char(self.writer, v)
- }
- fn emit_str(&mut self, v: &str) -> EncodeResult<()> {
- escape_str(self.writer, v)
- }
-
- fn emit_enum<F>(&mut self, _name: &str, f: F) -> EncodeResult<()> where
- F: FnOnce(&mut Encoder<'a>) -> EncodeResult<()>,
- {
- f(self)
- }
-
- fn emit_enum_variant<F>(&mut self,
- name: &str,
- _id: usize,
- cnt: usize,
- f: F)
- -> EncodeResult<()> where
- F: FnOnce(&mut Encoder<'a>) -> EncodeResult<()>,
- {
- // enums are encoded as strings or objects
- // Bunny => "Bunny"
- // Kangaroo(34,"William") => {"variant": "Kangaroo", "fields": [34,"William"]}
- if cnt == 0 {
- escape_str(self.writer, name)
- } else {
- if self.is_emitting_map_key { return Err(EncoderError::BadHashmapKey); }
- if let EncodingFormat::Pretty{ref mut curr_indent, indent} = self.format {
- try!(write!(self.writer, "{{\n"));
- *curr_indent += indent;
- try!(spaces(self.writer, *curr_indent));
- try!(write!(self.writer, "\"variant\": "));
- try!(escape_str(self.writer, name));
- try!(write!(self.writer, ",\n"));
- try!(spaces(self.writer, *curr_indent));
- try!(write!(self.writer, "\"fields\": [\n"));
- *curr_indent += indent;
- } else {
- try!(write!(self.writer, "{{\"variant\":"));
- try!(escape_str(self.writer, name));
- try!(write!(self.writer, ",\"fields\":["));
- }
- try!(f(self));
- if let EncodingFormat::Pretty{ref mut curr_indent, indent} = self.format {
- *curr_indent -= indent;
- try!(write!(self.writer, "\n"));
- try!(spaces(self.writer, *curr_indent));
- *curr_indent -= indent;
- try!(write!(self.writer, "]\n"));
- try!(spaces(self.writer, *curr_indent));
- try!(write!(self.writer, "}}"));
- } else {
- try!(write!(self.writer, "]}}"));
- }
- Ok(())
- }
- }
-
- fn emit_enum_variant_arg<F>(&mut self, idx: usize, f: F) -> EncodeResult<()> where
- F: FnOnce(&mut Encoder<'a>) -> EncodeResult<()>,
- {
- if self.is_emitting_map_key { return Err(EncoderError::BadHashmapKey); }
- if idx != 0 {
- try!(write!(self.writer, ","));
- if let EncodingFormat::Pretty{..} = self.format {
- try!(write!(self.writer, "\n"));
- }
- }
- if let EncodingFormat::Pretty{curr_indent, ..} = self.format {
- try!(spaces(self.writer, curr_indent));
- }
- f(self)
- }
-
- fn emit_enum_struct_variant<F>(&mut self,
- name: &str,
- id: usize,
- cnt: usize,
- f: F) -> EncodeResult<()> where
- F: FnOnce(&mut Encoder<'a>) -> EncodeResult<()>,
- {
- if self.is_emitting_map_key { return Err(EncoderError::BadHashmapKey); }
- self.emit_enum_variant(name, id, cnt, f)
- }
-
- fn emit_enum_struct_variant_field<F>(&mut self,
- _: &str,
- idx: usize,
- f: F) -> EncodeResult<()> where
- F: FnOnce(&mut Encoder<'a>) -> EncodeResult<()>,
- {
- if self.is_emitting_map_key { return Err(EncoderError::BadHashmapKey); }
- self.emit_enum_variant_arg(idx, f)
- }
-
-
- fn emit_struct<F>(&mut self, _: &str, len: usize, f: F) -> EncodeResult<()> where
- F: FnOnce(&mut Encoder<'a>) -> EncodeResult<()>,
- {
- if self.is_emitting_map_key { return Err(EncoderError::BadHashmapKey); }
- if len == 0 {
- try!(write!(self.writer, "{{}}"));
- } else {
- try!(write!(self.writer, "{{"));
- if let EncodingFormat::Pretty{ref mut curr_indent, indent} = self.format {
- *curr_indent += indent;
- }
- try!(f(self));
- if let EncodingFormat::Pretty{ref mut curr_indent, indent} = self.format {
- *curr_indent -= indent;
- try!(write!(self.writer, "\n"));
- try!(spaces(self.writer, *curr_indent));
- }
- try!(write!(self.writer, "}}"));
- }
- Ok(())
- }
-
- fn emit_struct_field<F>(&mut self, name: &str, idx: usize, f: F) -> EncodeResult<()> where
- F: FnOnce(&mut Encoder<'a>) -> EncodeResult<()>,
- {
- if self.is_emitting_map_key { return Err(EncoderError::BadHashmapKey); }
- if idx != 0 {
- try!(write!(self.writer, ","));
- }
- if let EncodingFormat::Pretty{curr_indent, ..} = self.format {
- try!(write!(self.writer, "\n"));
- try!(spaces(self.writer, curr_indent));
- }
- try!(escape_str(self.writer, name));
- if let EncodingFormat::Pretty{..} = self.format {
- try!(write!(self.writer, ": "));
- } else {
- try!(write!(self.writer, ":"));
- }
- f(self)
- }
-
- fn emit_tuple<F>(&mut self, len: usize, f: F) -> EncodeResult<()> where
- F: FnOnce(&mut Encoder<'a>) -> EncodeResult<()>,
- {
- if self.is_emitting_map_key { return Err(EncoderError::BadHashmapKey); }
- self.emit_seq(len, f)
- }
- fn emit_tuple_arg<F>(&mut self, idx: usize, f: F) -> EncodeResult<()> where
- F: FnOnce(&mut Encoder<'a>) -> EncodeResult<()>,
- {
- if self.is_emitting_map_key { return Err(EncoderError::BadHashmapKey); }
- self.emit_seq_elt(idx, f)
- }
-
- fn emit_tuple_struct<F>(&mut self, _: &str, len: usize, f: F) -> EncodeResult<()> where
- F: FnOnce(&mut Encoder<'a>) -> EncodeResult<()>,
- {
- if self.is_emitting_map_key { return Err(EncoderError::BadHashmapKey); }
- self.emit_seq(len, f)
- }
- fn emit_tuple_struct_arg<F>(&mut self, idx: usize, f: F) -> EncodeResult<()> where
- F: FnOnce(&mut Encoder<'a>) -> EncodeResult<()>,
- {
- if self.is_emitting_map_key { return Err(EncoderError::BadHashmapKey); }
- self.emit_seq_elt(idx, f)
- }
-
- fn emit_option<F>(&mut self, f: F) -> EncodeResult<()> where
- F: FnOnce(&mut Encoder<'a>) -> EncodeResult<()>,
- {
- if self.is_emitting_map_key { return Err(EncoderError::BadHashmapKey); }
- f(self)
- }
- fn emit_option_none(&mut self) -> EncodeResult<()> {
- if self.is_emitting_map_key { return Err(EncoderError::BadHashmapKey); }
- self.emit_nil()
- }
- fn emit_option_some<F>(&mut self, f: F) -> EncodeResult<()> where
- F: FnOnce(&mut Encoder<'a>) -> EncodeResult<()>,
- {
- if self.is_emitting_map_key { return Err(EncoderError::BadHashmapKey); }
- f(self)
- }
-
- fn emit_seq<F>(&mut self, len: usize, f: F) -> EncodeResult<()> where
- F: FnOnce(&mut Encoder<'a>) -> EncodeResult<()>,
- {
- if self.is_emitting_map_key { return Err(EncoderError::BadHashmapKey); }
- if len == 0 {
- try!(write!(self.writer, "[]"));
- } else {
- try!(write!(self.writer, "["));
- if let EncodingFormat::Pretty{ref mut curr_indent, indent} = self.format {
- *curr_indent += indent;
- }
- try!(f(self));
- if let EncodingFormat::Pretty{ref mut curr_indent, indent} = self.format {
- *curr_indent -= indent;
- try!(write!(self.writer, "\n"));
- try!(spaces(self.writer, *curr_indent));
- }
- try!(write!(self.writer, "]"));
- }
- Ok(())
- }
-
- fn emit_seq_elt<F>(&mut self, idx: usize, f: F) -> EncodeResult<()> where
- F: FnOnce(&mut Encoder<'a>) -> EncodeResult<()>,
- {
- if self.is_emitting_map_key { return Err(EncoderError::BadHashmapKey); }
- if idx != 0 {
- try!(write!(self.writer, ","));
- }
- if let EncodingFormat::Pretty{ref mut curr_indent, ..} = self.format {
- try!(write!(self.writer, "\n"));
- try!(spaces(self.writer, *curr_indent));
- }
- f(self)
- }
-
- fn emit_map<F>(&mut self, len: usize, f: F) -> EncodeResult<()> where
- F: FnOnce(&mut Encoder<'a>) -> EncodeResult<()>,
- {
- if self.is_emitting_map_key { return Err(EncoderError::BadHashmapKey); }
- if len == 0 {
- try!(write!(self.writer, "{{}}"));
- } else {
- try!(write!(self.writer, "{{"));
- if let EncodingFormat::Pretty{ref mut curr_indent, indent} = self.format {
- *curr_indent += indent;
- }
- try!(f(self));
- if let EncodingFormat::Pretty{ref mut curr_indent, indent} = self.format {
- *curr_indent -= indent;
- try!(write!(self.writer, "\n"));
- try!(spaces(self.writer, *curr_indent));
- }
- try!(write!(self.writer, "}}"));
- }
- Ok(())
- }
-
- fn emit_map_elt_key<F>(&mut self, idx: usize, f: F) -> EncodeResult<()> where
- F: FnOnce(&mut Encoder<'a>) -> EncodeResult<()>,
- {
- if self.is_emitting_map_key { return Err(EncoderError::BadHashmapKey); }
- if idx != 0 {
- try!(write!(self.writer, ","));
- }
- if let EncodingFormat::Pretty{curr_indent, ..} = self.format {
- try!(write!(self.writer, "\n"));
- try!(spaces(self.writer, curr_indent));
- }
- self.is_emitting_map_key = true;
- try!(f(self));
- self.is_emitting_map_key = false;
- Ok(())
- }
-
- fn emit_map_elt_val<F>(&mut self, _idx: usize, f: F) -> EncodeResult<()> where
- F: FnOnce(&mut Encoder<'a>) -> EncodeResult<()>,
- {
- if self.is_emitting_map_key { return Err(EncoderError::BadHashmapKey); }
- if let EncodingFormat::Pretty{..} = self.format {
- try!(write!(self.writer, ": "));
- } else {
- try!(write!(self.writer, ":"));
- }
- f(self)
- }
-}
-
-impl Encodable for Json {
- fn encode<S: ::Encoder>(&self, e: &mut S) -> Result<(), S::Error> {
- match *self {
- Json::I64(v) => v.encode(e),
- Json::U64(v) => v.encode(e),
- Json::F64(v) => v.encode(e),
- Json::String(ref v) => v.encode(e),
- Json::Boolean(v) => v.encode(e),
- Json::Array(ref v) => v.encode(e),
- Json::Object(ref v) => v.encode(e),
- Json::Null => e.emit_nil(),
- }
- }
-}
-
-/// Create an `AsJson` wrapper which can be used to print a value as JSON
-/// on-the-fly via `write!`
-pub fn as_json<T: Encodable>(t: &T) -> AsJson<T> {
- AsJson { inner: t }
-}
-
-/// Create an `AsPrettyJson` wrapper which can be used to print a value as JSON
-/// on-the-fly via `write!`
-pub fn as_pretty_json<T: Encodable>(t: &T) -> AsPrettyJson<T> {
- AsPrettyJson { inner: t, indent: None }
-}
-
-impl Json {
- /// Decodes a json value from an `&mut io::Read`
- pub fn from_reader(rdr: &mut io::Read) -> Result<Self, BuilderError> {
- let contents = {
- let mut c = Vec::new();
- try!(rdr.read_to_end(&mut c));
- c
- };
- let s = match str::from_utf8(&contents).ok() {
- Some(s) => s,
- _ => return Err(SyntaxError(NotUtf8, 0, 0))
- };
- let mut builder = Builder::new(s.chars());
- builder.build()
- }
-
- /// Decodes a json value from a string
- pub fn from_str(s: &str) -> Result<Self, BuilderError> {
- let mut builder = Builder::new(s.chars());
- builder.build()
- }
-
- /// Borrow this json object as a pretty object to generate a pretty
- /// representation for it via `Display`.
- pub fn pretty(&self) -> PrettyJson {
- PrettyJson { inner: self }
- }
-
- /// If the Json value is an Object, returns the value associated with the provided key.
- /// Otherwise, returns None.
- pub fn find<'a>(&'a self, key: &str) -> Option<&'a Json>{
- match self {
- &Json::Object(ref map) => map.get(key),
- _ => None
- }
- }
-
- /// Attempts to get a nested Json Object for each key in `keys`.
- /// If any key is found not to exist, find_path will return None.
- /// Otherwise, it will return the Json value associated with the final key.
- pub fn find_path<'a>(&'a self, keys: &[&str]) -> Option<&'a Json>{
- let mut target = self;
- for key in keys.iter() {
- match target.find(*key) {
- Some(t) => { target = t; },
- None => return None
- }
- }
- Some(target)
- }
-
- /// If the Json value is an Object, performs a depth-first search until
- /// a value associated with the provided key is found. If no value is found
- /// or the Json value is not an Object, returns None.
- pub fn search<'a>(&'a self, key: &str) -> Option<&'a Json> {
- match self {
- &Json::Object(ref map) => {
- match map.get(key) {
- Some(json_value) => Some(json_value),
- None => {
- for (_, v) in map.iter() {
- match v.search(key) {
- x if x.is_some() => return x,
- _ => ()
- }
- }
- None
- }
- }
- },
- _ => None
- }
- }
-
- /// Returns true if the Json value is an Object. Returns false otherwise.
- pub fn is_object<'a>(&'a self) -> bool {
- self.as_object().is_some()
- }
-
- /// If the Json value is an Object, returns a reference to the associated BTreeMap.
- /// Returns None otherwise.
- pub fn as_object<'a>(&'a self) -> Option<&'a Object> {
- match self {
- &Json::Object(ref map) => Some(map),
- _ => None
- }
- }
-
- /// If the Json value is an Object, returns a mutable reference to the associated BTreeMap.
- /// Returns None otherwise.
- pub fn as_object_mut<'a>(&'a mut self) -> Option<&'a mut Object> {
- match self {
- &mut Json::Object(ref mut map) => Some(map),
- _ => None
- }
- }
-
- /// If the Json value is an Object, returns the associated BTreeMap.
- /// Returns None otherwise.
- pub fn into_object(self) -> Option<Object> {
- match self {
- Json::Object(map) => Some(map),
- _ => None
- }
- }
-
- /// Returns true if the Json value is an Array. Returns false otherwise.
- pub fn is_array<'a>(&'a self) -> bool {
- self.as_array().is_some()
- }
-
- /// If the Json value is an Array, returns a reference to the associated vector.
- /// Returns None otherwise.
- pub fn as_array<'a>(&'a self) -> Option<&'a Array> {
- match self {
- &Json::Array(ref array) => Some(&*array),
- _ => None
- }
- }
-
- /// If the Json value is an Array, returns a mutable reference to the associated vector.
- /// Returns None otherwise.
- pub fn as_array_mut<'a>(&'a mut self) -> Option<&'a mut Array> {
- match self {
- &mut Json::Array(ref mut list) => Some(list),
- _ => None
- }
- }
-
- /// If the Json value is an Array, returns the associated vector.
- /// Returns None otherwise.
- pub fn into_array(self) -> Option<Array> {
- match self {
- Json::Array(array) => Some(array),
- _ => None
- }
- }
-
- /// Returns true if the Json value is a String. Returns false otherwise.
- pub fn is_string<'a>(&'a self) -> bool {
- self.as_string().is_some()
- }
-
- /// If the Json value is a String, returns the associated str.
- /// Returns None otherwise.
- pub fn as_string<'a>(&'a self) -> Option<&'a str> {
- match *self {
- Json::String(ref s) => Some(&s),
- _ => None
- }
- }
-
- /// Returns true if the Json value is a Number. Returns false otherwise.
- pub fn is_number(&self) -> bool {
- match *self {
- Json::I64(_) | Json::U64(_) | Json::F64(_) => true,
- _ => false,
- }
- }
-
- /// Returns true if the Json value is a i64. Returns false otherwise.
- pub fn is_i64(&self) -> bool {
- match *self {
- Json::I64(_) => true,
- _ => false,
- }
- }
-
- /// Returns true if the Json value is a u64. Returns false otherwise.
- pub fn is_u64(&self) -> bool {
- match *self {
- Json::U64(_) => true,
- _ => false,
- }
- }
-
- /// Returns true if the Json value is a f64. Returns false otherwise.
- pub fn is_f64(&self) -> bool {
- match *self {
- Json::F64(_) => true,
- _ => false,
- }
- }
-
- /// If the Json value is a number, return or cast it to a i64.
- /// Returns None otherwise.
- pub fn as_i64(&self) -> Option<i64> {
- match *self {
- Json::I64(n) => Some(n),
- Json::U64(n) if n >= i64::MAX as u64 => None,
- Json::U64(n) => Some(n as i64),
- _ => None
- }
- }
-
- /// If the Json value is a number, return or cast it to a u64.
- /// Returns None otherwise.
- pub fn as_u64(&self) -> Option<u64> {
- match *self {
- Json::I64(n) if n >= 0 => Some(n as u64),
- Json::U64(n) => Some(n),
- _ => None
- }
- }
-
- /// If the Json value is a number, return or cast it to a f64.
- /// Returns None otherwise.
- pub fn as_f64(&self) -> Option<f64> {
- match *self {
- Json::I64(n) => Some(n as f64),
- Json::U64(n) => Some(n as f64),
- Json::F64(n) => Some(n),
- _ => None
- }
- }
-
- /// Returns true if the Json value is a Boolean. Returns false otherwise.
- pub fn is_boolean(&self) -> bool {
- self.as_boolean().is_some()
- }
-
- /// If the Json value is a Boolean, returns the associated bool.
- /// Returns None otherwise.
- pub fn as_boolean(&self) -> Option<bool> {
- match self {
- &Json::Boolean(b) => Some(b),
- _ => None
- }
- }
-
- /// Returns true if the Json value is a Null. Returns false otherwise.
- pub fn is_null(&self) -> bool {
- self.as_null().is_some()
- }
-
- /// If the Json value is a Null, returns ().
- /// Returns None otherwise.
- pub fn as_null(&self) -> Option<()> {
- match self {
- &Json::Null => Some(()),
- _ => None
- }
- }
-}
-
-impl<'a> Index<&'a str> for Json {
- type Output = Json;
-
- fn index(&self, idx: &str) -> &Json {
- self.find(idx).unwrap()
- }
-}
-
-impl Index<usize> for Json {
- type Output = Json;
-
- fn index<'a>(&'a self, idx: usize) -> &'a Json {
- match self {
- &Json::Array(ref v) => &v[idx],
- _ => panic!("can only index Json with usize if it is an array")
- }
- }
-}
-
-/// The output of the streaming parser.
-#[derive(PartialEq, Debug)]
-pub enum JsonEvent {
- ObjectStart,
- ObjectEnd,
- ArrayStart,
- ArrayEnd,
- BooleanValue(bool),
- I64Value(i64),
- U64Value(u64),
- F64Value(f64),
- StringValue(string::String),
- NullValue,
- Error(ParserError),
-}
-
-#[derive(PartialEq, Debug)]
-enum ParserState {
- // Parse a value in an array, true means first element.
- ParseArray(bool),
- // Parse ',' or ']' after an element in an array.
- ParseArrayComma,
- // Parse a key:value in an object, true means first element.
- ParseObject(bool),
- // Parse ',' or ']' after an element in an object.
- ParseObjectComma,
- // Initial state.
- ParseStart,
- // Expecting the stream to end.
- ParseBeforeFinish,
- // Parsing can't continue.
- ParseFinished,
-}
-
-/// A Stack represents the current position of the parser in the logical
-/// structure of the JSON stream.
-/// For example foo.bar[3].x
-pub struct Stack {
- stack: Vec<InternalStackElement>,
- str_buffer: Vec<u8>,
-}
-
-/// StackElements compose a Stack.
-/// For example, Key("foo"), Key("bar"), Index(3) and Key("x") are the
-/// StackElements compositing the stack that represents foo.bar[3].x
-#[derive(PartialEq, Clone, Debug)]
-pub enum StackElement<'l> {
- Index(u32),
- Key(&'l str),
-}
-
-// Internally, Key elements are stored as indices in a buffer to avoid
-// allocating a string for every member of an object.
-#[derive(PartialEq, Clone, Debug)]
-enum InternalStackElement {
- InternalIndex(u32),
- InternalKey(u16, u16), // start, size
-}
-
-impl Stack {
- pub fn new() -> Stack {
- Stack { stack: Vec::new(), str_buffer: Vec::new() }
- }
-
- /// Returns The number of elements in the Stack.
- pub fn len(&self) -> usize { self.stack.len() }
-
- /// Returns true if the stack is empty.
- pub fn is_empty(&self) -> bool { self.stack.is_empty() }
-
- /// Provides access to the StackElement at a given index.
- /// lower indices are at the bottom of the stack while higher indices are
- /// at the top.
- pub fn get<'l>(&'l self, idx: usize) -> StackElement<'l> {
- match self.stack[idx] {
- InternalIndex(i) => StackElement::Index(i),
- InternalKey(start, size) => {
- StackElement::Key(str::from_utf8(
- &self.str_buffer[start as usize .. start as usize + size as usize]).unwrap())
- }
- }
- }
-
- /// Compares this stack with an array of StackElements.
- pub fn is_equal_to(&self, rhs: &[StackElement]) -> bool {
- if self.stack.len() != rhs.len() { return false; }
- for i in 0..rhs.len() {
- if self.get(i) != rhs[i] { return false; }
- }
- return true;
- }
-
- /// Returns true if the bottom-most elements of this stack are the same as
- /// the ones passed as parameter.
- pub fn starts_with(&self, rhs: &[StackElement]) -> bool {
- if self.stack.len() < rhs.len() { return false; }
- for i in 0..rhs.len() {
- if self.get(i) != rhs[i] { return false; }
- }
- return true;
- }
-
- /// Returns true if the top-most elements of this stack are the same as
- /// the ones passed as parameter.
- pub fn ends_with(&self, rhs: &[StackElement]) -> bool {
- if self.stack.len() < rhs.len() { return false; }
- let offset = self.stack.len() - rhs.len();
- for i in 0..rhs.len() {
- if self.get(i + offset) != rhs[i] { return false; }
- }
- return true;
- }
-
- /// Returns the top-most element (if any).
- pub fn top<'l>(&'l self) -> Option<StackElement<'l>> {
- return match self.stack.last() {
- None => None,
- Some(&InternalIndex(i)) => Some(StackElement::Index(i)),
- Some(&InternalKey(start, size)) => {
- Some(StackElement::Key(str::from_utf8(
- &self.str_buffer[start as usize .. (start+size) as usize]
- ).unwrap()))
- }
- }
- }
-
- // Used by Parser to insert Key elements at the top of the stack.
- fn push_key(&mut self, key: string::String) {
- self.stack.push(InternalKey(self.str_buffer.len() as u16, key.len() as u16));
- for c in key.as_bytes().iter() {
- self.str_buffer.push(*c);
- }
- }
-
- // Used by Parser to insert Index elements at the top of the stack.
- fn push_index(&mut self, index: u32) {
- self.stack.push(InternalIndex(index));
- }
-
- // Used by Parser to remove the top-most element of the stack.
- fn pop(&mut self) {
- assert!(!self.is_empty());
- match *self.stack.last().unwrap() {
- InternalKey(_, sz) => {
- let new_size = self.str_buffer.len() - sz as usize;
- self.str_buffer.truncate(new_size);
- }
- InternalIndex(_) => {}
- }
- self.stack.pop();
- }
-
- // Used by Parser to test whether the top-most element is an index.
- fn last_is_index(&self) -> bool {
- if self.is_empty() { return false; }
- return match *self.stack.last().unwrap() {
- InternalIndex(_) => true,
- _ => false,
- }
- }
-
- // Used by Parser to increment the index of the top-most element.
- fn bump_index(&mut self) {
- let len = self.stack.len();
- let idx = match *self.stack.last().unwrap() {
- InternalIndex(i) => { i + 1 }
- _ => { panic!(); }
- };
- self.stack[len - 1] = InternalIndex(idx);
- }
-}
-
-/// A streaming JSON parser implemented as an iterator of JsonEvent, consuming
-/// an iterator of char.
-pub struct Parser<T> {
- rdr: T,
- ch: Option<char>,
- line: usize,
- col: usize,
- // We maintain a stack representing where we are in the logical structure
- // of the JSON stream.
- stack: Stack,
- // A state machine is kept to make it possible to interrupt and resume parsing.
- state: ParserState,
-}
-
-impl<T: Iterator<Item = char>> Iterator for Parser<T> {
- type Item = JsonEvent;
-
- fn next(&mut self) -> Option<JsonEvent> {
- if self.state == ParseFinished {
- return None;
- }
-
- if self.state == ParseBeforeFinish {
- self.parse_whitespace();
- // Make sure there is no trailing characters.
- if self.eof() {
- self.state = ParseFinished;
- return None;
- } else {
- return Some(self.error_event(TrailingCharacters));
- }
- }
-
- return Some(self.parse());
- }
-}
-
-impl<T: Iterator<Item = char>> Parser<T> {
- /// Creates the JSON parser.
- pub fn new(rdr: T) -> Parser<T> {
- let mut p = Parser {
- rdr: rdr,
- ch: Some('\x00'),
- line: 1,
- col: 0,
- stack: Stack::new(),
- state: ParseStart,
- };
- p.bump();
- return p;
- }
-
- /// Provides access to the current position in the logical structure of the
- /// JSON stream.
- pub fn stack<'l>(&'l self) -> &'l Stack {
- return &self.stack;
- }
-
- fn eof(&self) -> bool { self.ch.is_none() }
- fn ch_or_null(&self) -> char { self.ch.unwrap_or('\x00') }
- fn bump(&mut self) {
- self.ch = self.rdr.next();
-
- if self.ch_is('\n') {
- self.line += 1;
- self.col = 1;
- } else {
- self.col += 1;
- }
- }
-
- fn next_char(&mut self) -> Option<char> {
- self.bump();
- self.ch
- }
- fn ch_is(&self, c: char) -> bool {
- self.ch == Some(c)
- }
-
- fn error<E>(&self, reason: ErrorCode) -> Result<E, ParserError> {
- Err(SyntaxError(reason, self.line, self.col))
- }
-
- fn parse_whitespace(&mut self) {
- while self.ch_is(' ') ||
- self.ch_is('\n') ||
- self.ch_is('\t') ||
- self.ch_is('\r') { self.bump(); }
- }
-
- fn parse_number(&mut self) -> JsonEvent {
- let mut neg = false;
-
- if self.ch_is('-') {
- self.bump();
- neg = true;
- }
-
- let res = match self.parse_u64() {
- Ok(res) => res,
- Err(e) => { return Error(e); }
- };
-
- if self.ch_is('.') || self.ch_is('e') || self.ch_is('E') {
- let mut res = res as f64;
-
- if self.ch_is('.') {
- res = match self.parse_decimal(res) {
- Ok(res) => res,
- Err(e) => { return Error(e); }
- };
- }
-
- if self.ch_is('e') || self.ch_is('E') {
- res = match self.parse_exponent(res) {
- Ok(res) => res,
- Err(e) => { return Error(e); }
- };
- }
-
- if neg {
- res *= -1.0;
- }
-
- F64Value(res)
- } else {
- if neg {
- // Make sure we don't underflow.
- if res > (i64::MAX as u64) + 1 {
- Error(SyntaxError(InvalidNumber, self.line, self.col))
- } else if res == 0 {
- I64Value(res as i64)
- } else {
- I64Value((!res + 1) as i64)
- }
- } else {
- U64Value(res)
- }
- }
- }
-
- fn parse_u64(&mut self) -> Result<u64, ParserError> {
- let mut accum: u64 = 0;
-
- match self.ch_or_null() {
- '0' => {
- self.bump();
-
- // A leading '0' must be the only digit before the decimal point.
- match self.ch_or_null() {
- '0' ... '9' => return self.error(InvalidNumber),
- _ => ()
- }
- },
- '1' ... '9' => {
- while !self.eof() {
- match self.ch_or_null() {
- c @ '0' ... '9' => {
- macro_rules! try_or_invalid {
- ($e: expr) => {
- match $e {
- Some(v) => v,
- None => return self.error(InvalidNumber)
- }
- }
- }
- accum = try_or_invalid!(accum.checked_mul(10));
- accum = try_or_invalid!(accum.checked_add((c as u64) - ('0' as u64)));
-
- self.bump();
- }
- _ => break,
- }
- }
- }
- _ => return self.error(InvalidNumber),
- }
-
- Ok(accum)
- }
-
- fn parse_decimal(&mut self, mut res: f64) -> Result<f64, ParserError> {
- self.bump();
-
- // Make sure a digit follows the decimal place.
- match self.ch_or_null() {
- '0' ... '9' => (),
- _ => return self.error(InvalidNumber)
- }
-
- let mut dec = 1.0;
- let mut frac = 0.0;
- while !self.eof() {
- match self.ch_or_null() {
- c @ '0' ... '9' => {
- dec /= 10.0;
- frac += (((c as isize) - ('0' as isize)) as f64) * dec;
- self.bump();
- }
- _ => break,
- }
- }
-
- res += frac;
-
- Ok(res)
- }
-
- fn parse_exponent(&mut self, mut res: f64) -> Result<f64, ParserError> {
- self.bump();
-
- let mut exp = 0;
- let mut neg_exp = false;
-
- if self.ch_is('+') {
- self.bump();
- } else if self.ch_is('-') {
- self.bump();
- neg_exp = true;
- }
-
- // Make sure a digit follows the exponent place.
- match self.ch_or_null() {
- '0' ... '9' => (),
- _ => return self.error(InvalidNumber)
- }
- while !self.eof() {
- match self.ch_or_null() {
- c @ '0' ... '9' => {
- exp *= 10;
- exp += (c as usize) - ('0' as usize);
-
- self.bump();
- }
- _ => break
- }
- }
-
- let exp = 10_f64.powi(exp as i32);
- if neg_exp {
- res /= exp;
- } else {
- res *= exp;
- }
-
- Ok(res)
- }
-
- fn decode_hex_escape(&mut self) -> Result<u16, ParserError> {
- let mut i = 0;
- let mut n = 0;
- while i < 4 {
- self.bump();
- n = match self.ch_or_null() {
- c @ '0' ... '9' => n * 16 + ((c as u16) - ('0' as u16)),
- c @ 'a' ... 'f' => n * 16 + (10 + (c as u16) - ('a' as u16)),
- c @ 'A' ... 'F' => n * 16 + (10 + (c as u16) - ('A' as u16)),
- _ => return self.error(InvalidEscape)
- };
-
- i += 1;
- }
-
- Ok(n)
- }
-
- fn parse_str(&mut self) -> Result<string::String, ParserError> {
- let mut escape = false;
- let mut res = string::String::new();
-
- loop {
- self.bump();
- if self.eof() {
- return self.error(EOFWhileParsingString);
- }
-
- if escape {
- match self.ch_or_null() {
- '"' => res.push('"'),
- '\\' => res.push('\\'),
- '/' => res.push('/'),
- 'b' => res.push('\x08'),
- 'f' => res.push('\x0c'),
- 'n' => res.push('\n'),
- 'r' => res.push('\r'),
- 't' => res.push('\t'),
- 'u' => match try!(self.decode_hex_escape()) {
- 0xDC00 ... 0xDFFF => {
- return self.error(LoneLeadingSurrogateInHexEscape)
- }
-
- // Non-BMP characters are encoded as a sequence of
- // two hex escapes, representing UTF-16 surrogates.
- n1 @ 0xD800 ... 0xDBFF => {
- match (self.next_char(), self.next_char()) {
- (Some('\\'), Some('u')) => (),
- _ => return self.error(UnexpectedEndOfHexEscape),
- }
-
- let n2 = try!(self.decode_hex_escape());
- if n2 < 0xDC00 || n2 > 0xDFFF {
- return self.error(LoneLeadingSurrogateInHexEscape)
- }
- let c = (((n1 - 0xD800) as u32) << 10 |
- (n2 - 0xDC00) as u32) + 0x1_0000;
- res.push(char::from_u32(c).unwrap());
- }
-
- n => match char::from_u32(n as u32) {
- Some(c) => res.push(c),
- None => return self.error(InvalidUnicodeCodePoint),
- },
- },
- _ => return self.error(InvalidEscape),
- }
- escape = false;
- } else if self.ch_is('\\') {
- escape = true;
- } else {
- match self.ch {
- Some('"') => {
- self.bump();
- return Ok(res);
- },
- Some(c) if c <= '\u{1F}' =>
- return self.error(ControlCharacterInString),
- Some(c) => res.push(c),
- None => unreachable!()
- }
- }
- }
- }
-
- // Invoked at each iteration, consumes the stream until it has enough
- // information to return a JsonEvent.
- // Manages an internal state so that parsing can be interrupted and resumed.
- // Also keeps track of the position in the logical structure of the json
- // stream int the form of a stack that can be queried by the user using the
- // stack() method.
- fn parse(&mut self) -> JsonEvent {
- loop {
- // The only paths where the loop can spin a new iteration
- // are in the cases ParseArrayComma and ParseObjectComma if ','
- // is parsed. In these cases the state is set to (respectively)
- // ParseArray(false) and ParseObject(false), which always return,
- // so there is no risk of getting stuck in an infinite loop.
- // All other paths return before the end of the loop's iteration.
- self.parse_whitespace();
-
- match self.state {
- ParseStart => {
- return self.parse_start();
- }
- ParseArray(first) => {
- return self.parse_array(first);
- }
- ParseArrayComma => {
- match self.parse_array_comma_or_end() {
- Some(evt) => { return evt; }
- None => {}
- }
- }
- ParseObject(first) => {
- return self.parse_object(first);
- }
- ParseObjectComma => {
- self.stack.pop();
- if self.ch_is(',') {
- self.state = ParseObject(false);
- self.bump();
- } else {
- return self.parse_object_end();
- }
- }
- _ => {
- return self.error_event(InvalidSyntax);
- }
- }
- }
- }
-
- fn parse_start(&mut self) -> JsonEvent {
- let val = self.parse_value();
- self.state = match val {
- Error(_) => ParseFinished,
- ArrayStart => ParseArray(true),
- ObjectStart => ParseObject(true),
- _ => ParseBeforeFinish,
- };
- return val;
- }
-
- fn parse_array(&mut self, first: bool) -> JsonEvent {
- if self.ch_is(']') {
- if !first {
- self.error_event(InvalidSyntax)
- } else {
- self.state = if self.stack.is_empty() {
- ParseBeforeFinish
- } else if self.stack.last_is_index() {
- ParseArrayComma
- } else {
- ParseObjectComma
- };
- self.bump();
- ArrayEnd
- }
- } else {
- if first {
- self.stack.push_index(0);
- }
- let val = self.parse_value();
- self.state = match val {
- Error(_) => ParseFinished,
- ArrayStart => ParseArray(true),
- ObjectStart => ParseObject(true),
- _ => ParseArrayComma,
- };
- val
- }
- }
-
- fn parse_array_comma_or_end(&mut self) -> Option<JsonEvent> {
- if self.ch_is(',') {
- self.stack.bump_index();
- self.state = ParseArray(false);
- self.bump();
- None
- } else if self.ch_is(']') {
- self.stack.pop();
- self.state = if self.stack.is_empty() {
- ParseBeforeFinish
- } else if self.stack.last_is_index() {
- ParseArrayComma
- } else {
- ParseObjectComma
- };
- self.bump();
- Some(ArrayEnd)
- } else if self.eof() {
- Some(self.error_event(EOFWhileParsingArray))
- } else {
- Some(self.error_event(InvalidSyntax))
- }
- }
-
- fn parse_object(&mut self, first: bool) -> JsonEvent {
- if self.ch_is('}') {
- if !first {
- if self.stack.is_empty() {
- return self.error_event(TrailingComma);
- } else {
- self.stack.pop();
- }
- }
- self.state = if self.stack.is_empty() {
- ParseBeforeFinish
- } else if self.stack.last_is_index() {
- ParseArrayComma
- } else {
- ParseObjectComma
- };
- self.bump();
- return ObjectEnd;
- }
- if self.eof() {
- return self.error_event(EOFWhileParsingObject);
- }
- if !self.ch_is('"') {
- return self.error_event(KeyMustBeAString);
- }
- let s = match self.parse_str() {
- Ok(s) => s,
- Err(e) => {
- self.state = ParseFinished;
- return Error(e);
- }
- };
- self.parse_whitespace();
- if self.eof() {
- return self.error_event(EOFWhileParsingObject);
- } else if self.ch_or_null() != ':' {
- return self.error_event(ExpectedColon);
- }
- self.stack.push_key(s);
- self.bump();
- self.parse_whitespace();
-
- let val = self.parse_value();
-
- self.state = match val {
- Error(_) => ParseFinished,
- ArrayStart => ParseArray(true),
- ObjectStart => ParseObject(true),
- _ => ParseObjectComma,
- };
- return val;
- }
-
- fn parse_object_end(&mut self) -> JsonEvent {
- if self.ch_is('}') {
- self.state = if self.stack.is_empty() {
- ParseBeforeFinish
- } else if self.stack.last_is_index() {
- ParseArrayComma
- } else {
- ParseObjectComma
- };
- self.bump();
- ObjectEnd
- } else if self.eof() {
- self.error_event(EOFWhileParsingObject)
- } else {
- self.error_event(InvalidSyntax)
- }
- }
-
- fn parse_value(&mut self) -> JsonEvent {
- if self.eof() { return self.error_event(EOFWhileParsingValue); }
- match self.ch_or_null() {
- 'n' => { self.parse_ident("ull", NullValue) }
- 't' => { self.parse_ident("rue", BooleanValue(true)) }
- 'f' => { self.parse_ident("alse", BooleanValue(false)) }
- '0' ... '9' | '-' => self.parse_number(),
- '"' => match self.parse_str() {
- Ok(s) => StringValue(s),
- Err(e) => Error(e),
- },
- '[' => {
- self.bump();
- ArrayStart
- }
- '{' => {
- self.bump();
- ObjectStart
- }
- _ => { self.error_event(InvalidSyntax) }
- }
- }
-
- fn parse_ident(&mut self, ident: &str, value: JsonEvent) -> JsonEvent {
- if ident.chars().all(|c| Some(c) == self.next_char()) {
- self.bump();
- value
- } else {
- Error(SyntaxError(InvalidSyntax, self.line, self.col))
- }
- }
-
- fn error_event(&mut self, reason: ErrorCode) -> JsonEvent {
- self.state = ParseFinished;
- Error(SyntaxError(reason, self.line, self.col))
- }
-}
-
-/// A Builder consumes a json::Parser to create a generic Json structure.
-pub struct Builder<T> {
- parser: Parser<T>,
- token: Option<JsonEvent>,
-}
-
-impl<T: Iterator<Item = char>> Builder<T> {
- /// Create a JSON Builder.
- pub fn new(src: T) -> Builder<T> {
- Builder { parser: Parser::new(src), token: None, }
- }
-
- // Decode a Json value from a Parser.
- pub fn build(&mut self) -> Result<Json, BuilderError> {
- self.bump();
- let result = self.build_value();
- self.bump();
- match self.token.take() {
- None => {}
- Some(Error(e)) => { return Err(e); }
- _ => { return Err(SyntaxError(InvalidSyntax, self.parser.line, self.parser.col)); }
- }
- result
- }
-
- fn bump(&mut self) {
- self.token = self.parser.next();
- }
-
- fn build_value(&mut self) -> Result<Json, BuilderError> {
- return match self.token.take() {
- Some(NullValue) => Ok(Json::Null),
- Some(I64Value(n)) => Ok(Json::I64(n)),
- Some(U64Value(n)) => Ok(Json::U64(n)),
- Some(F64Value(n)) => Ok(Json::F64(n)),
- Some(BooleanValue(b)) => Ok(Json::Boolean(b)),
- Some(StringValue(ref mut s)) => {
- let mut temp = string::String::new();
- swap(s, &mut temp);
- Ok(Json::String(temp))
- }
- Some(Error(e)) => Err(e),
- Some(ArrayStart) => self.build_array(),
- Some(ObjectStart) => self.build_object(),
- Some(ObjectEnd) => self.parser.error(InvalidSyntax),
- Some(ArrayEnd) => self.parser.error(InvalidSyntax),
- None => self.parser.error(EOFWhileParsingValue),
- }
- }
-
- fn build_array(&mut self) -> Result<Json, BuilderError> {
- self.bump();
- let mut values = Vec::new();
-
- loop {
- if let Some(ArrayEnd) = self.token {
- return Ok(Json::Array(values.into_iter().collect()));
- }
- match self.build_value() {
- Ok(v) => values.push(v),
- Err(e) => { return Err(e) }
- }
- self.bump();
- }
- }
-
- fn build_object(&mut self) -> Result<Json, BuilderError> {
- self.bump();
-
- let mut values = BTreeMap::new();
-
- loop {
- match self.token.take() {
- Some(ObjectEnd) => { return Ok(Json::Object(values)); }
- Some(Error(e)) => { return Err(e); }
- None => { break; }
- token => { self.token = token; }
- }
- let key = match self.parser.stack().top() {
- Some(StackElement::Key(k)) => { k.to_string() }
- _ => { panic!("invalid state"); }
- };
- match self.build_value() {
- Ok(value) => { values.insert(key, value); }
- Err(e) => { return Err(e); }
- }
- self.bump();
- }
- return self.parser.error(EOFWhileParsingObject);
- }
-}
-
-/// A structure to decode JSON to values in rust.
-pub struct Decoder {
- stack: Vec<Json>,
-}
-
-impl Decoder {
- /// Creates a new decoder instance for decoding the specified JSON value.
- pub fn new(json: Json) -> Decoder {
- Decoder { stack: vec![json] }
- }
-}
-
-impl Decoder {
- fn pop(&mut self) -> DecodeResult<Json> {
- match self.stack.pop() {
- Some(s) => Ok(s),
- None => Err(EOF),
- }
- }
-}
-
-macro_rules! expect {
- ($e:expr, Null) => ({
- match try!($e) {
- Json::Null => Ok(()),
- other => Err(ExpectedError("Null".to_string(),
- format!("{}", other)))
- }
- });
- ($e:expr, $t:ident) => ({
- match try!($e) {
- Json::$t(v) => Ok(v),
- other => {
- Err(ExpectedError(stringify!($t).to_string(),
- format!("{}", other)))
- }
- }
- })
-}
-
-macro_rules! read_primitive {
- ($name:ident, $ty:ident) => {
- #[allow(unused_comparisons)]
- fn $name(&mut self) -> DecodeResult<$ty> {
- match try!(self.pop()) {
- Json::I64(i) => {
- let other = i as $ty;
- if i == other as i64 && (other > 0) == (i > 0) {
- Ok(other)
- } else {
- Err(ExpectedError("Number".to_string(), i.to_string()))
- }
- }
- Json::U64(u) => {
- let other = u as $ty;
- if u == other as u64 && other >= 0 {
- Ok(other)
- } else {
- Err(ExpectedError("Number".to_string(), u.to_string()))
- }
- }
- Json::F64(f) => {
- Err(ExpectedError("Integer".to_string(), f.to_string()))
- }
- // re: #12967.. a type w/ numeric keys (ie HashMap<usize, V> etc)
- // is going to have a string here, as per JSON spec.
- Json::String(s) => match s.parse() {
- Ok(f) => Ok(f),
- Err(_) => Err(ExpectedError("Number".to_string(), s)),
- },
- value => {
- Err(ExpectedError("Number".to_string(), value.to_string()))
- }
- }
- }
- }
-}
-
-impl ::Decoder for Decoder {
- type Error = DecoderError;
-
- fn read_nil(&mut self) -> DecodeResult<()> {
- expect!(self.pop(), Null)
- }
-
- read_primitive! { read_usize, usize }
- read_primitive! { read_u8, u8 }
- read_primitive! { read_u16, u16 }
- read_primitive! { read_u32, u32 }
- read_primitive! { read_u64, u64 }
- read_primitive! { read_isize, isize }
- read_primitive! { read_i8, i8 }
- read_primitive! { read_i16, i16 }
- read_primitive! { read_i32, i32 }
- read_primitive! { read_i64, i64 }
-
- fn read_f32(&mut self) -> DecodeResult<f32> {
- self.read_f64().map(|x| x as f32)
- }
-
- fn read_f64(&mut self) -> DecodeResult<f64> {
- match try!(self.pop()) {
- Json::I64(f) => Ok(f as f64),
- Json::U64(f) => Ok(f as f64),
- Json::F64(f) => Ok(f),
- Json::String(s) => {
- // re: #12967.. a type w/ numeric keys (ie HashMap<usize, V> etc)
- // is going to have a string here, as per JSON spec.
- match s.parse() {
- Ok(f) => Ok(f),
- Err(_) => Err(ExpectedError("Number".to_string(), s)),
- }
- },
- Json::Null => Ok(f64::NAN),
- value => Err(ExpectedError("Number".to_string(), format!("{}", value)))
- }
- }
-
- fn read_bool(&mut self) -> DecodeResult<bool> {
- expect!(self.pop(), Boolean)
- }
-
- fn read_char(&mut self) -> DecodeResult<char> {
- let s = try!(self.read_str());
- {
- let mut it = s.chars();
- match (it.next(), it.next()) {
- // exactly one character
- (Some(c), None) => return Ok(c),
- _ => ()
- }
- }
- Err(ExpectedError("single character string".to_string(), format!("{}", s)))
- }
-
- fn read_str(&mut self) -> DecodeResult<string::String> {
- expect!(self.pop(), String)
- }
-
- fn read_enum<T, F>(&mut self, _name: &str, f: F) -> DecodeResult<T> where
- F: FnOnce(&mut Decoder) -> DecodeResult<T>,
- {
- f(self)
- }
-
- fn read_enum_variant<T, F>(&mut self, names: &[&str],
- mut f: F) -> DecodeResult<T>
- where F: FnMut(&mut Decoder, usize) -> DecodeResult<T>,
- {
- let name = match try!(self.pop()) {
- Json::String(s) => s,
- Json::Object(mut o) => {
- let n = match o.remove(&"variant".to_string()) {
- Some(Json::String(s)) => s,
- Some(val) => {
- return Err(ExpectedError("String".to_string(), format!("{}", val)))
- }
- None => {
- return Err(MissingFieldError("variant".to_string()))
- }
- };
- match o.remove(&"fields".to_string()) {
- Some(Json::Array(l)) => {
- for field in l.into_iter().rev() {
- self.stack.push(field);
- }
- },
- Some(val) => {
- return Err(ExpectedError("Array".to_string(), format!("{}", val)))
- }
- None => {
- return Err(MissingFieldError("fields".to_string()))
- }
- }
- n
- }
- json => {
- return Err(ExpectedError("String or Object".to_string(), format!("{}", json)))
- }
- };
- let idx = match names.iter().position(|n| *n == name) {
- Some(idx) => idx,
- None => return Err(UnknownVariantError(name))
- };
- f(self, idx)
- }
-
- fn read_enum_variant_arg<T, F>(&mut self, _idx: usize, f: F) -> DecodeResult<T> where
- F: FnOnce(&mut Decoder) -> DecodeResult<T>,
- {
- f(self)
- }
-
- fn read_enum_struct_variant<T, F>(&mut self, names: &[&str], f: F) -> DecodeResult<T> where
- F: FnMut(&mut Decoder, usize) -> DecodeResult<T>,
- {
- self.read_enum_variant(names, f)
- }
-
-
- fn read_enum_struct_variant_field<T, F>(&mut self,
- _name: &str,
- idx: usize,
- f: F)
- -> DecodeResult<T> where
- F: FnOnce(&mut Decoder) -> DecodeResult<T>,
- {
- self.read_enum_variant_arg(idx, f)
- }
-
- fn read_struct<T, F>(&mut self, _name: &str, _len: usize, f: F) -> DecodeResult<T> where
- F: FnOnce(&mut Decoder) -> DecodeResult<T>,
- {
- let value = try!(f(self));
- try!(self.pop());
- Ok(value)
- }
-
- fn read_struct_field<T, F>(&mut self,
- name: &str,
- _idx: usize,
- f: F)
- -> DecodeResult<T> where
- F: FnOnce(&mut Decoder) -> DecodeResult<T>,
- {
- let mut obj = try!(expect!(self.pop(), Object));
-
- let value = match obj.remove(&name.to_string()) {
- None => {
- // Add a Null and try to parse it as an Option<_>
- // to get None as a default value.
- self.stack.push(Json::Null);
- match f(self) {
- Ok(x) => x,
- Err(_) => return Err(MissingFieldError(name.to_string())),
- }
- },
- Some(json) => {
- self.stack.push(json);
- try!(f(self))
- }
- };
- self.stack.push(Json::Object(obj));
- Ok(value)
- }
-
- fn read_tuple<T, F>(&mut self, tuple_len: usize, f: F) -> DecodeResult<T> where
- F: FnOnce(&mut Decoder) -> DecodeResult<T>,
- {
- self.read_seq(move |d, len| {
- if len == tuple_len {
- f(d)
- } else {
- Err(ExpectedError(format!("Tuple{}", tuple_len), format!("Tuple{}", len)))
- }
- })
- }
-
- fn read_tuple_arg<T, F>(&mut self, idx: usize, f: F) -> DecodeResult<T> where
- F: FnOnce(&mut Decoder) -> DecodeResult<T>,
- {
- self.read_seq_elt(idx, f)
- }
-
- fn read_tuple_struct<T, F>(&mut self,
- _name: &str,
- len: usize,
- f: F)
- -> DecodeResult<T> where
- F: FnOnce(&mut Decoder) -> DecodeResult<T>,
- {
- self.read_tuple(len, f)
- }
-
- fn read_tuple_struct_arg<T, F>(&mut self,
- idx: usize,
- f: F)
- -> DecodeResult<T> where
- F: FnOnce(&mut Decoder) -> DecodeResult<T>,
- {
- self.read_tuple_arg(idx, f)
- }
-
- fn read_option<T, F>(&mut self, mut f: F) -> DecodeResult<T> where
- F: FnMut(&mut Decoder, bool) -> DecodeResult<T>,
- {
- match try!(self.pop()) {
- Json::Null => f(self, false),
- value => { self.stack.push(value); f(self, true) }
- }
- }
-
- fn read_seq<T, F>(&mut self, f: F) -> DecodeResult<T> where
- F: FnOnce(&mut Decoder, usize) -> DecodeResult<T>,
- {
- let array = try!(expect!(self.pop(), Array));
- let len = array.len();
- for v in array.into_iter().rev() {
- self.stack.push(v);
- }
- f(self, len)
- }
-
- fn read_seq_elt<T, F>(&mut self, _idx: usize, f: F) -> DecodeResult<T> where
- F: FnOnce(&mut Decoder) -> DecodeResult<T>,
- {
- f(self)
- }
-
- fn read_map<T, F>(&mut self, f: F) -> DecodeResult<T> where
- F: FnOnce(&mut Decoder, usize) -> DecodeResult<T>,
- {
- let obj = try!(expect!(self.pop(), Object));
- let len = obj.len();
- for (key, value) in obj.into_iter() {
- self.stack.push(value);
- self.stack.push(Json::String(key));
- }
- f(self, len)
- }
-
- fn read_map_elt_key<T, F>(&mut self, _idx: usize, f: F) -> DecodeResult<T> where
- F: FnOnce(&mut Decoder) -> DecodeResult<T>,
- {
- f(self)
- }
-
- fn read_map_elt_val<T, F>(&mut self, _idx: usize, f: F) -> DecodeResult<T> where
- F: FnOnce(&mut Decoder) -> DecodeResult<T>,
- {
- f(self)
- }
-
- fn error(&mut self, err: &str) -> DecoderError {
- ApplicationError(err.to_string())
- }
-}
-
-/// A trait for converting values to JSON
-pub trait ToJson {
- /// Converts the value of `self` to an instance of JSON
- fn to_json(&self) -> Json;
-}
-
-macro_rules! to_json_impl_i64 {
- ($($t:ty), +) => (
- $(impl ToJson for $t {
- fn to_json(&self) -> Json { Json::I64(*self as i64) }
- })+
- )
-}
-
-to_json_impl_i64! { isize, i8, i16, i32, i64 }
-
-macro_rules! to_json_impl_u64 {
- ($($t:ty), +) => (
- $(impl ToJson for $t {
- fn to_json(&self) -> Json { Json::U64(*self as u64) }
- })+
- )
-}
-
-to_json_impl_u64! { usize, u8, u16, u32, u64 }
-
-impl ToJson for Json {
- fn to_json(&self) -> Json { self.clone() }
-}
-
-impl ToJson for f32 {
- fn to_json(&self) -> Json { (*self as f64).to_json() }
-}
-
-impl ToJson for f64 {
- fn to_json(&self) -> Json {
- use std::num::FpCategory::{Nan, Infinite};
-
- match self.classify() {
- Nan | Infinite => Json::Null,
- _ => Json::F64(*self)
- }
- }
-}
-
-impl ToJson for () {
- fn to_json(&self) -> Json { Json::Null }
-}
-
-impl ToJson for bool {
- fn to_json(&self) -> Json { Json::Boolean(*self) }
-}
-
-impl ToJson for str {
- fn to_json(&self) -> Json { Json::String(self.to_string()) }
-}
-
-impl ToJson for string::String {
- fn to_json(&self) -> Json { Json::String((*self).clone()) }
-}
-
-macro_rules! tuple_impl {
- // use variables to indicate the arity of the tuple
- ($($tyvar:ident),* ) => {
- // the trailing commas are for the 1 tuple
- impl<
- $( $tyvar : ToJson ),*
- > ToJson for ( $( $tyvar ),* , ) {
-
- #[inline]
- #[allow(non_snake_case)]
- fn to_json(&self) -> Json {
- match *self {
- ($(ref $tyvar),*,) => Json::Array(vec![$($tyvar.to_json()),*])
- }
- }
- }
- }
-}
-
-tuple_impl!{A}
-tuple_impl!{A, B}
-tuple_impl!{A, B, C}
-tuple_impl!{A, B, C, D}
-tuple_impl!{A, B, C, D, E}
-tuple_impl!{A, B, C, D, E, F}
-tuple_impl!{A, B, C, D, E, F, G}
-tuple_impl!{A, B, C, D, E, F, G, H}
-tuple_impl!{A, B, C, D, E, F, G, H, I}
-tuple_impl!{A, B, C, D, E, F, G, H, I, J}
-tuple_impl!{A, B, C, D, E, F, G, H, I, J, K}
-tuple_impl!{A, B, C, D, E, F, G, H, I, J, K, L}
-
-impl<A: ToJson> ToJson for [A] {
- fn to_json(&self) -> Json { Json::Array(self.iter().map(|elt| elt.to_json()).collect()) }
-}
-
-impl<A: ToJson> ToJson for Vec<A> {
- fn to_json(&self) -> Json { Json::Array(self.iter().map(|elt| elt.to_json()).collect()) }
-}
-
-impl<A: ToJson> ToJson for BTreeMap<string::String, A> {
- fn to_json(&self) -> Json {
- let mut d = BTreeMap::new();
- for (key, value) in self.iter() {
- d.insert((*key).clone(), value.to_json());
- }
- Json::Object(d)
- }
-}
-
-impl<A: ToJson> ToJson for HashMap<string::String, A> {
- fn to_json(&self) -> Json {
- let mut d = BTreeMap::new();
- for (key, value) in self.iter() {
- d.insert((*key).clone(), value.to_json());
- }
- Json::Object(d)
- }
-}
-
-impl<A:ToJson> ToJson for Option<A> {
- fn to_json(&self) -> Json {
- match *self {
- None => Json::Null,
- Some(ref value) => value.to_json()
- }
- }
-}
-
-struct FormatShim<'a, 'b: 'a> {
- inner: &'a mut fmt::Formatter<'b>,
-}
-
-impl<'a, 'b> fmt::Write for FormatShim<'a, 'b> {
- fn write_str(&mut self, s: &str) -> fmt::Result {
- match self.inner.write_str(s) {
- Ok(_) => Ok(()),
- Err(_) => Err(fmt::Error)
- }
- }
-}
-
-impl fmt::Display for Json {
- /// Encodes a json value into a string
- fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
- let mut shim = FormatShim { inner: f };
- let mut encoder = Encoder::new(&mut shim);
- match self.encode(&mut encoder) {
- Ok(_) => Ok(()),
- Err(_) => Err(fmt::Error)
- }
- }
-}
-
-impl<'a> fmt::Display for PrettyJson<'a> {
- /// Encodes a json value into a string
- fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
- let mut shim = FormatShim { inner: f };
- let mut encoder = Encoder::new_pretty(&mut shim);
- match self.inner.encode(&mut encoder) {
- Ok(_) => Ok(()),
- Err(_) => Err(fmt::Error)
- }
- }
-}
-
-impl<'a, T: Encodable> fmt::Display for AsJson<'a, T> {
- /// Encodes a json value into a string
- fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
- let mut shim = FormatShim { inner: f };
- let mut encoder = Encoder::new(&mut shim);
- match self.inner.encode(&mut encoder) {
- Ok(_) => Ok(()),
- Err(_) => Err(fmt::Error)
- }
- }
-}
-
-impl<'a, T> AsPrettyJson<'a, T> {
- /// Set the indentation level for the emitted JSON
- pub fn indent(mut self, indent: u32) -> AsPrettyJson<'a, T> {
- self.indent = Some(indent);
- self
- }
-}
-
-impl<'a, T: Encodable> fmt::Display for AsPrettyJson<'a, T> {
- /// Encodes a json value into a string
- fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
- let mut shim = FormatShim { inner: f };
- let mut encoder = Encoder::new_pretty(&mut shim);
- if let Some(n) = self.indent {
- // unwrap cannot panic for pretty encoders
- let _ = encoder.set_indent(n);
- }
- match self.inner.encode(&mut encoder) {
- Ok(_) => Ok(()),
- Err(_) => Err(fmt::Error)
- }
- }
-}
-
-impl FromStr for Json {
- type Err = ParserError;
- fn from_str(s: &str) -> Result<Json, ParserError> {
- Json::from_str(s)
- }
-}
-
-#[cfg(test)]
-mod tests {
- use self::Animal::*;
- use {Encodable, Decodable};
- use super::Json::*;
- use super::ErrorCode::*;
- use super::ParserError::*;
- use super::DecoderError::*;
- use super::JsonEvent::*;
- use super::StackElement::*;
- use super::{Json, DecodeResult, DecoderError, JsonEvent, Parser,
- StackElement, Stack, Decoder, Encoder, EncoderError};
- use std::{i64, u64, f32, f64};
- use std::collections::BTreeMap;
- use std::string;
-
- #[derive(RustcDecodable, Eq, PartialEq, Debug)]
- struct OptionData {
- opt: Option<usize>,
- }
-
- #[test]
- fn test_decode_option_none() {
- let s ="{}";
- let obj: OptionData = super::decode(s).unwrap();
- assert_eq!(obj, OptionData { opt: None });
- }
-
- #[test]
- fn test_decode_option_some() {
- let s = "{ \"opt\": 10 }";
- let obj: OptionData = super::decode(s).unwrap();
- assert_eq!(obj, OptionData { opt: Some(10) });
- }
-
- #[test]
- fn test_decode_option_malformed() {
- check_err::<OptionData>("{ \"opt\": [] }",
- ExpectedError("Number".to_string(), "[]".to_string()));
- check_err::<OptionData>("{ \"opt\": false }",
- ExpectedError("Number".to_string(), "false".to_string()));
- }
-
- #[derive(PartialEq, RustcEncodable, RustcDecodable, Debug)]
- enum Animal {
- Dog,
- Frog(string::String, isize)
- }
-
- #[derive(PartialEq, RustcEncodable, RustcDecodable, Debug)]
- struct Inner {
- a: (),
- b: usize,
- c: Vec<string::String>,
- }
-
- #[derive(PartialEq, RustcEncodable, RustcDecodable, Debug)]
- struct Outer {
- inner: Vec<Inner>,
- }
-
- fn mk_object(items: &[(string::String, Json)]) -> Json {
- let mut d = BTreeMap::new();
-
- for item in items.iter() {
- match *item {
- (ref key, ref value) => { d.insert((*key).clone(), (*value).clone()); },
- }
- };
-
- Object(d)
- }
-
- #[test]
- fn test_from_str_trait() {
- let s = "null";
- assert!(s.parse::<Json>().unwrap() == s.parse().unwrap());
- }
-
- #[test]
- fn test_write_null() {
- assert_eq!(Null.to_string(), "null");
- assert_eq!(Null.pretty().to_string(), "null");
- }
-
- #[test]
- fn test_write_i64() {
- assert_eq!(U64(0).to_string(), "0");
- assert_eq!(U64(0).pretty().to_string(), "0");
-
- assert_eq!(U64(1234).to_string(), "1234");
- assert_eq!(U64(1234).pretty().to_string(), "1234");
-
- assert_eq!(I64(-5678).to_string(), "-5678");
- assert_eq!(I64(-5678).pretty().to_string(), "-5678");
-
- assert_eq!(U64(7650007200025252000).to_string(), "7650007200025252000");
- assert_eq!(U64(7650007200025252000).pretty().to_string(), "7650007200025252000");
- }
-
- #[test]
- fn test_write_f64() {
- assert_eq!(F64(3.0).to_string(), "3.0");
- assert_eq!(F64(3.0).pretty().to_string(), "3.0");
-
- assert_eq!(F64(3.1).to_string(), "3.1");
- assert_eq!(F64(3.1).pretty().to_string(), "3.1");
-
- assert_eq!(F64(-1.5).to_string(), "-1.5");
- assert_eq!(F64(-1.5).pretty().to_string(), "-1.5");
-
- assert_eq!(F64(0.5).to_string(), "0.5");
- assert_eq!(F64(0.5).pretty().to_string(), "0.5");
-
- assert_eq!(F64(f64::NAN).to_string(), "null");
- assert_eq!(F64(f64::NAN).pretty().to_string(), "null");
-
- assert_eq!(F64(f64::INFINITY).to_string(), "null");
- assert_eq!(F64(f64::INFINITY).pretty().to_string(), "null");
-
- assert_eq!(F64(f64::NEG_INFINITY).to_string(), "null");
- assert_eq!(F64(f64::NEG_INFINITY).pretty().to_string(), "null");
- }
-
- #[test]
- fn test_write_str() {
- assert_eq!(String("".to_string()).to_string(), "\"\"");
- assert_eq!(String("".to_string()).pretty().to_string(), "\"\"");
-
- assert_eq!(String("homura".to_string()).to_string(), "\"homura\"");
- assert_eq!(String("madoka".to_string()).pretty().to_string(), "\"madoka\"");
- }
-
- #[test]
- fn test_write_bool() {
- assert_eq!(Boolean(true).to_string(), "true");
- assert_eq!(Boolean(true).pretty().to_string(), "true");
-
- assert_eq!(Boolean(false).to_string(), "false");
- assert_eq!(Boolean(false).pretty().to_string(), "false");
- }
-
- #[test]
- fn test_write_array() {
- assert_eq!(Array(vec![]).to_string(), "[]");
- assert_eq!(Array(vec![]).pretty().to_string(), "[]");
-
- assert_eq!(Array(vec![Boolean(true)]).to_string(), "[true]");
- assert_eq!(
- Array(vec![Boolean(true)]).pretty().to_string(),
- "\
- [\n \
- true\n\
- ]"
- );
-
- let long_test_array = Array(vec![
- Boolean(false),
- Null,
- Array(vec![String("foo\nbar".to_string()), F64(3.5)])]);
-
- assert_eq!(long_test_array.to_string(),
- "[false,null,[\"foo\\nbar\",3.5]]");
- assert_eq!(
- long_test_array.pretty().to_string(),
- "\
- [\n \
- false,\n \
- null,\n \
- [\n \
- \"foo\\nbar\",\n \
- 3.5\n \
- ]\n\
- ]"
- );
- }
-
- #[test]
- fn test_write_object() {
- assert_eq!(mk_object(&[]).to_string(), "{}");
- assert_eq!(mk_object(&[]).pretty().to_string(), "{}");
-
- assert_eq!(
- mk_object(&[
- ("a".to_string(), Boolean(true))
- ]).to_string(),
- "{\"a\":true}"
- );
- assert_eq!(
- mk_object(&[("a".to_string(), Boolean(true))]).pretty().to_string(),
- "\
- {\n \
- \"a\": true\n\
- }"
- );
-
- let complex_obj = mk_object(&[
- ("b".to_string(), Array(vec![
- mk_object(&[("c".to_string(), String("\x0c\r".to_string()))]),
- mk_object(&[("d".to_string(), String("".to_string()))])
- ]))
- ]);
-
- assert_eq!(
- complex_obj.to_string(),
- "{\
- \"b\":[\
- {\"c\":\"\\f\\r\"},\
- {\"d\":\"\"}\
- ]\
- }"
- );
- assert_eq!(
- complex_obj.pretty().to_string(),
- "\
- {\n \
- \"b\": [\n \
- {\n \
- \"c\": \"\\f\\r\"\n \
- },\n \
- {\n \
- \"d\": \"\"\n \
- }\n \
- ]\n\
- }"
- );
-
- let a = mk_object(&[
- ("a".to_string(), Boolean(true)),
- ("b".to_string(), Array(vec![
- mk_object(&[("c".to_string(), String("\x0c\r".to_string()))]),
- mk_object(&[("d".to_string(), String("".to_string()))])
- ]))
- ]);
-
- // We can't compare the strings directly because the object fields be
- // printed in a different order.
- assert_eq!(a.clone(), a.to_string().parse().unwrap());
- assert_eq!(a.clone(), a.pretty().to_string().parse().unwrap());
- }
-
- #[test]
- fn test_write_enum() {
- let animal = Dog;
- assert_eq!(
- format!("{}", super::as_json(&animal)),
- "\"Dog\""
- );
- assert_eq!(
- format!("{}", super::as_pretty_json(&animal)),
- "\"Dog\""
- );
-
- let animal = Frog("Henry".to_string(), 349);
- assert_eq!(
- format!("{}", super::as_json(&animal)),
- "{\"variant\":\"Frog\",\"fields\":[\"Henry\",349]}"
- );
- assert_eq!(
- format!("{}", super::as_pretty_json(&animal)),
- "{\n \
- \"variant\": \"Frog\",\n \
- \"fields\": [\n \
- \"Henry\",\n \
- 349\n \
- ]\n\
- }"
- );
- }
-
- macro_rules! check_encoder_for_simple {
- ($value:expr, $expected:expr) => ({
- let s = format!("{}", super::as_json(&$value));
- assert_eq!(s, $expected);
-
- let s = format!("{}", super::as_pretty_json(&$value));
- assert_eq!(s, $expected);
- })
- }
-
- #[test]
- fn test_write_some() {
- check_encoder_for_simple!(Some("jodhpurs".to_string()), "\"jodhpurs\"");
- }
-
- #[test]
- fn test_write_none() {
- check_encoder_for_simple!(None::<string::String>, "null");
- }
-
- #[test]
- fn test_write_char() {
- check_encoder_for_simple!('a', "\"a\"");
- check_encoder_for_simple!('\t', "\"\\t\"");
- check_encoder_for_simple!('\u{0000}', "\"\\u0000\"");
- check_encoder_for_simple!('\u{001b}', "\"\\u001b\"");
- check_encoder_for_simple!('\u{007f}', "\"\\u007f\"");
- check_encoder_for_simple!('\u{00a0}', "\"\u{00a0}\"");
- check_encoder_for_simple!('\u{abcd}', "\"\u{abcd}\"");
- check_encoder_for_simple!('\u{10ffff}', "\"\u{10ffff}\"");
- }
-
- #[test]
- fn test_trailing_characters() {
- assert_eq!(Json::from_str("nulla"), Err(SyntaxError(TrailingCharacters, 1, 5)));
- assert_eq!(Json::from_str("truea"), Err(SyntaxError(TrailingCharacters, 1, 5)));
- assert_eq!(Json::from_str("falsea"), Err(SyntaxError(TrailingCharacters, 1, 6)));
- assert_eq!(Json::from_str("1a"), Err(SyntaxError(TrailingCharacters, 1, 2)));
- assert_eq!(Json::from_str("[]a"), Err(SyntaxError(TrailingCharacters, 1, 3)));
- assert_eq!(Json::from_str("{}a"), Err(SyntaxError(TrailingCharacters, 1, 3)));
- }
-
- #[test]
- fn test_read_identifiers() {
- assert_eq!(Json::from_str("n"), Err(SyntaxError(InvalidSyntax, 1, 2)));
- assert_eq!(Json::from_str("nul"), Err(SyntaxError(InvalidSyntax, 1, 4)));
- assert_eq!(Json::from_str("t"), Err(SyntaxError(InvalidSyntax, 1, 2)));
- assert_eq!(Json::from_str("truz"), Err(SyntaxError(InvalidSyntax, 1, 4)));
- assert_eq!(Json::from_str("f"), Err(SyntaxError(InvalidSyntax, 1, 2)));
- assert_eq!(Json::from_str("faz"), Err(SyntaxError(InvalidSyntax, 1, 3)));
-
- assert_eq!(Json::from_str("null"), Ok(Null));
- assert_eq!(Json::from_str("true"), Ok(Boolean(true)));
- assert_eq!(Json::from_str("false"), Ok(Boolean(false)));
- assert_eq!(Json::from_str(" null "), Ok(Null));
- assert_eq!(Json::from_str(" true "), Ok(Boolean(true)));
- assert_eq!(Json::from_str(" false "), Ok(Boolean(false)));
- }
-
- #[test]
- fn test_decode_identifiers() {
- let v: () = super::decode("null").unwrap();
- assert_eq!(v, ());
-
- let v: bool = super::decode("true").unwrap();
- assert_eq!(v, true);
-
- let v: bool = super::decode("false").unwrap();
- assert_eq!(v, false);
- }
-
- #[test]
- fn test_read_number() {
- assert_eq!(Json::from_str("+"), Err(SyntaxError(InvalidSyntax, 1, 1)));
- assert_eq!(Json::from_str("."), Err(SyntaxError(InvalidSyntax, 1, 1)));
- assert_eq!(Json::from_str("NaN"), Err(SyntaxError(InvalidSyntax, 1, 1)));
- assert_eq!(Json::from_str("-"), Err(SyntaxError(InvalidNumber, 1, 2)));
- assert_eq!(Json::from_str("00"), Err(SyntaxError(InvalidNumber, 1, 2)));
- assert_eq!(Json::from_str("1."), Err(SyntaxError(InvalidNumber, 1, 3)));
- assert_eq!(Json::from_str("1e"), Err(SyntaxError(InvalidNumber, 1, 3)));
- assert_eq!(Json::from_str("1e+"), Err(SyntaxError(InvalidNumber, 1, 4)));
-
- assert_eq!(Json::from_str("18446744073709551616"), Err(SyntaxError(InvalidNumber, 1, 20)));
- assert_eq!(Json::from_str("18446744073709551617"), Err(SyntaxError(InvalidNumber, 1, 20)));
- assert_eq!(Json::from_str("-9223372036854775809"), Err(SyntaxError(InvalidNumber, 1, 21)));
-
- assert_eq!(Json::from_str("3"), Ok(U64(3)));
- assert_eq!(Json::from_str("3.1"), Ok(F64(3.1)));
- assert_eq!(Json::from_str("-1.2"), Ok(F64(-1.2)));
- assert_eq!(Json::from_str("0.4"), Ok(F64(0.4)));
- assert_eq!(Json::from_str("0.4e5"), Ok(F64(0.4e5)));
- assert_eq!(Json::from_str("0.4e+15"), Ok(F64(0.4e15)));
- assert_eq!(Json::from_str("0.4e-01"), Ok(F64(0.4e-01)));
- assert_eq!(Json::from_str("123456789.5024"), Ok(F64(123456789.5024)));
- assert_eq!(Json::from_str(" 3 "), Ok(U64(3)));
-
- assert_eq!(Json::from_str("-9223372036854775808"), Ok(I64(i64::MIN)));
- assert_eq!(Json::from_str("9223372036854775807"), Ok(U64(i64::MAX as u64)));
- assert_eq!(Json::from_str("18446744073709551615"), Ok(U64(u64::MAX)));
- }
-
- #[test]
- fn test_decode_numbers() {
- let v: f64 = super::decode("3").unwrap();
- assert_eq!(v, 3.0);
-
- let v: f64 = super::decode("3.1").unwrap();
- assert_eq!(v, 3.1);
-
- let v: f64 = super::decode("-1.2").unwrap();
- assert_eq!(v, -1.2);
-
- let v: f64 = super::decode("0.4").unwrap();
- assert_eq!(v, 0.4);
-
- let v: f64 = super::decode("0.4e5").unwrap();
- assert_eq!(v, 0.4e5);
-
- let v: f64 = super::decode("0.4e15").unwrap();
- assert_eq!(v, 0.4e15);
-
- let v: f64 = super::decode("0.4e-01").unwrap();
- assert_eq!(v, 0.4e-01);
-
- let v: f64 = super::decode("123456789.5024").unwrap();
- assert_eq!(v, 123456789.5024);
-
- let v: u64 = super::decode("0").unwrap();
- assert_eq!(v, 0);
-
- let v: u64 = super::decode("18446744073709551615").unwrap();
- assert_eq!(v, u64::MAX);
-
- let v: i64 = super::decode("-9223372036854775808").unwrap();
- assert_eq!(v, i64::MIN);
-
- let v: i64 = super::decode("9223372036854775807").unwrap();
- assert_eq!(v, i64::MAX);
-
- let res: DecodeResult<i64> = super::decode("765.25252");
- match res {
- Ok(..) => panic!("expected an error"),
- Err(ExpectedError(ref s, _)) => assert_eq!(s, "Integer"),
- Err(..) => panic!("expected an 'expected integer' error"),
- }
- }
-
- #[test]
- fn test_read_str() {
- assert_eq!(Json::from_str("\""), Err(SyntaxError(EOFWhileParsingString, 1, 2)));
- assert_eq!(Json::from_str("\"lol"), Err(SyntaxError(EOFWhileParsingString, 1, 5)));
- assert_eq!(Json::from_str("\"\n\""), Err(SyntaxError(ControlCharacterInString, 2, 1)));
- assert_eq!(Json::from_str("\"\0\""), Err(SyntaxError(ControlCharacterInString, 1, 2)));
- assert_eq!(Json::from_str("\"\u{1}\""), Err(SyntaxError(ControlCharacterInString, 1, 2)));
- assert_eq!(Json::from_str("\"\u{1F}\""), Err(SyntaxError(ControlCharacterInString, 1, 2)));
-
- // Only C0 control characters are excluded.
- assert!('\u{7F}'.is_control());
- assert!('\u{80}'.is_control());
- assert!('\u{9F}'.is_control());
- let c1_controls = "\u{7F}\u{80}\u{9F}".to_string();
- assert_eq!(Json::from_str(&format!("\"{}\"", c1_controls)), Ok(String(c1_controls)));
-
- assert_eq!(Json::from_str("\"\""), Ok(String("".to_string())));
- assert_eq!(Json::from_str("\"foo\""), Ok(String("foo".to_string())));
- assert_eq!(Json::from_str("\"\\\"\""), Ok(String("\"".to_string())));
- assert_eq!(Json::from_str("\"\\b\""), Ok(String("\x08".to_string())));
- assert_eq!(Json::from_str("\"\\n\""), Ok(String("\n".to_string())));
- assert_eq!(Json::from_str("\"\\r\""), Ok(String("\r".to_string())));
- assert_eq!(Json::from_str("\"\\t\""), Ok(String("\t".to_string())));
- assert_eq!(Json::from_str(" \"foo\" "), Ok(String("foo".to_string())));
- assert_eq!(Json::from_str("\"\\u12ab\""), Ok(String("\u{12ab}".to_string())));
- assert_eq!(Json::from_str("\"\\uAB12\""), Ok(String("\u{AB12}".to_string())));
- }
-
- #[test]
- fn test_decode_str() {
- let s = [("\"\"", ""),
- ("\"foo\"", "foo"),
- ("\"\\\"\"", "\""),
- ("\"\\b\"", "\x08"),
- ("\"\\n\"", "\n"),
- ("\"\\r\"", "\r"),
- ("\"\\t\"", "\t"),
- ("\"\\u12ab\"", "\u{12ab}"),
- ("\"\\uAB12\"", "\u{AB12}")];
-
- for &(i, o) in s.iter() {
- let v: string::String = super::decode(i).unwrap();
- assert_eq!(v, o);
- }
- }
-
- #[test]
- fn test_read_array() {
- assert_eq!(Json::from_str("["), Err(SyntaxError(EOFWhileParsingValue, 1, 2)));
- assert_eq!(Json::from_str("[1"), Err(SyntaxError(EOFWhileParsingArray, 1, 3)));
- assert_eq!(Json::from_str("[1,"), Err(SyntaxError(EOFWhileParsingValue, 1, 4)));
- assert_eq!(Json::from_str("[1,]"), Err(SyntaxError(InvalidSyntax, 1, 4)));
- assert_eq!(Json::from_str("[6 7]"), Err(SyntaxError(InvalidSyntax, 1, 4)));
-
- assert_eq!(Json::from_str("[]"), Ok(Array(vec![])));
- assert_eq!(Json::from_str("[ ]"), Ok(Array(vec![])));
- assert_eq!(Json::from_str("[true]"), Ok(Array(vec![Boolean(true)])));
- assert_eq!(Json::from_str("[ false ]"), Ok(Array(vec![Boolean(false)])));
- assert_eq!(Json::from_str("[null]"), Ok(Array(vec![Null])));
- assert_eq!(Json::from_str("[3, 1]"),
- Ok(Array(vec![U64(3), U64(1)])));
- assert_eq!(Json::from_str("\n[3, 2]\n"),
- Ok(Array(vec![U64(3), U64(2)])));
- assert_eq!(Json::from_str("[2, [4, 1]]"),
- Ok(Array(vec![U64(2), Array(vec![U64(4), U64(1)])])));
- }
-
- #[test]
- fn test_decode_array() {
- let v: Vec<()> = super::decode("[]").unwrap();
- assert_eq!(v, vec![]);
-
- let v: Vec<()> = super::decode("[null]").unwrap();
- assert_eq!(v, vec![()]);
-
- let v: Vec<bool> = super::decode("[true]").unwrap();
- assert_eq!(v, vec![true]);
-
- let v: Vec<isize> = super::decode("[3, 1]").unwrap();
- assert_eq!(v, vec![3, 1]);
-
- let v: Vec<Vec<usize>> = super::decode("[[3], [1, 2]]").unwrap();
- assert_eq!(v, vec![vec![3], vec![1, 2]]);
- }
-
- #[test]
- fn test_decode_tuple() {
- let t: (usize, usize, usize) = super::decode("[1, 2, 3]").unwrap();
- assert_eq!(t, (1, 2, 3));
-
- let t: (usize, string::String) = super::decode("[1, \"two\"]").unwrap();
- assert_eq!(t, (1, "two".to_string()));
- }
-
- #[test]
- fn test_decode_tuple_malformed_types() {
- assert!(super::decode::<(usize, string::String)>("[1, 2]").is_err());
- }
-
- #[test]
- fn test_decode_tuple_malformed_length() {
- assert!(super::decode::<(usize, usize)>("[1, 2, 3]").is_err());
- }
-
- #[test]
- fn test_read_object() {
- assert_eq!(Json::from_str("{"), Err(SyntaxError(EOFWhileParsingObject, 1, 2)));
- assert_eq!(Json::from_str("{ "), Err(SyntaxError(EOFWhileParsingObject, 1, 3)));
- assert_eq!(Json::from_str("{1"), Err(SyntaxError(KeyMustBeAString, 1, 2)));
- assert_eq!(Json::from_str("{ \"a\""), Err(SyntaxError(EOFWhileParsingObject, 1, 6)));
- assert_eq!(Json::from_str("{\"a\""), Err(SyntaxError(EOFWhileParsingObject, 1, 5)));
- assert_eq!(Json::from_str("{\"a\" "), Err(SyntaxError(EOFWhileParsingObject, 1, 6)));
-
- assert_eq!(Json::from_str("{\"a\" 1"), Err(SyntaxError(ExpectedColon, 1, 6)));
- assert_eq!(Json::from_str("{\"a\":"), Err(SyntaxError(EOFWhileParsingValue, 1, 6)));
- assert_eq!(Json::from_str("{\"a\":1"), Err(SyntaxError(EOFWhileParsingObject, 1, 7)));
- assert_eq!(Json::from_str("{\"a\":1 1"), Err(SyntaxError(InvalidSyntax, 1, 8)));
- assert_eq!(Json::from_str("{\"a\":1,"), Err(SyntaxError(EOFWhileParsingObject, 1, 8)));
-
- assert_eq!(Json::from_str("{}").unwrap(), mk_object(&[]));
- assert_eq!(Json::from_str("{\"a\": 3}").unwrap(),
- mk_object(&[("a".to_string(), U64(3))]));
-
- assert_eq!(Json::from_str(
- "{ \"a\": null, \"b\" : true }").unwrap(),
- mk_object(&[
- ("a".to_string(), Null),
- ("b".to_string(), Boolean(true))]));
- assert_eq!(Json::from_str("\n{ \"a\": null, \"b\" : true }\n").unwrap(),
- mk_object(&[
- ("a".to_string(), Null),
- ("b".to_string(), Boolean(true))]));
- assert_eq!(Json::from_str(
- "{\"a\" : 1.0 ,\"b\": [ true ]}").unwrap(),
- mk_object(&[
- ("a".to_string(), F64(1.0)),
- ("b".to_string(), Array(vec![Boolean(true)]))
- ]));
- assert_eq!(Json::from_str(
- "{\
- \"a\": 1.0, \
- \"b\": [\
- true,\
- \"foo\\nbar\", \
- { \"c\": {\"d\": null} } \
- ]\
- }").unwrap(),
- mk_object(&[
- ("a".to_string(), F64(1.0)),
- ("b".to_string(), Array(vec![
- Boolean(true),
- String("foo\nbar".to_string()),
- mk_object(&[
- ("c".to_string(), mk_object(&[("d".to_string(), Null)]))
- ])
- ]))
- ]));
- }
-
- #[test]
- fn test_decode_struct() {
- let s = "{
- \"inner\": [
- { \"a\": null, \"b\": 2, \"c\": [\"abc\", \"xyz\"] }
- ]
- }";
-
- let v: Outer = super::decode(s).unwrap();
- assert_eq!(
- v,
- Outer {
- inner: vec![
- Inner { a: (), b: 2, c: vec!["abc".to_string(), "xyz".to_string()] }
- ]
- }
- );
- }
-
- #[derive(RustcDecodable)]
- struct FloatStruct {
- f: f64,
- a: Vec<f64>
- }
- #[test]
- fn test_decode_struct_with_nan() {
- let s = "{\"f\":null,\"a\":[null,123]}";
- let obj: FloatStruct = super::decode(s).unwrap();
- assert!(obj.f.is_nan());
- assert!(obj.a[0].is_nan());
- assert_eq!(obj.a[1], 123f64);
- }
-
- #[test]
- fn test_decode_option() {
- let value: Option<string::String> = super::decode("null").unwrap();
- assert_eq!(value, None);
-
- let value: Option<string::String> = super::decode("\"jodhpurs\"").unwrap();
- assert_eq!(value, Some("jodhpurs".to_string()));
- }
-
- #[test]
- fn test_decode_enum() {
- let value: Animal = super::decode("\"Dog\"").unwrap();
- assert_eq!(value, Dog);
-
- let s = "{\"variant\":\"Frog\",\"fields\":[\"Henry\",349]}";
- let value: Animal = super::decode(s).unwrap();
- assert_eq!(value, Frog("Henry".to_string(), 349));
- }
-
- #[test]
- fn test_decode_result() {
- let value: Result<i32, i8> = Ok(4);
- let json_value = super::encode(&value).unwrap();
- assert_eq!(json_value, "{\"variant\":\"Ok\",\"fields\":[4]}");
- let decoded_value: Result<i32, i8> = super::decode(&json_value).unwrap();
- assert_eq!(decoded_value, Ok(4));
- }
-
- #[test]
- fn test_decode_map() {
- let s = "{\"a\": \"Dog\", \"b\": {\"variant\":\"Frog\",\
- \"fields\":[\"Henry\", 349]}}";
- let mut map: BTreeMap<string::String, Animal> = super::decode(s).unwrap();
-
- assert_eq!(map.remove(&"a".to_string()), Some(Dog));
- assert_eq!(map.remove(&"b".to_string()), Some(Frog("Henry".to_string(), 349)));
- }
-
- #[test]
- fn test_multiline_errors() {
- assert_eq!(Json::from_str("{\n \"foo\":\n \"bar\""),
- Err(SyntaxError(EOFWhileParsingObject, 3, 8)));
- }
-
- #[derive(RustcDecodable)]
- #[allow(dead_code)]
- struct DecodeStruct {
- x: f64,
- y: bool,
- z: string::String,
- w: Vec<DecodeStruct>
- }
- #[derive(RustcDecodable)]
- enum DecodeEnum {
- A(f64),
- B(string::String)
- }
- fn check_err<T: Decodable>(to_parse: &'static str, expected: DecoderError) {
- let res: DecodeResult<T> = match Json::from_str(to_parse) {
- Err(e) => Err(ParseError(e)),
- Ok(json) => Decodable::decode(&mut Decoder::new(json))
- };
- match res {
- Ok(_) => panic!("`{:?}` parsed & decoded ok, expecting error `{:?}`",
- to_parse, expected),
- Err(ParseError(e)) => panic!("`{}` is not valid json: {:?}",
- to_parse, e),
- Err(e) => {
- assert_eq!(e, expected);
- }
- }
- }
- #[test]
- fn test_decode_errors_struct() {
- check_err::<DecodeStruct>("[]", ExpectedError("Object".to_string(), "[]".to_string()));
- check_err::<DecodeStruct>("{\"x\": true, \"y\": true, \"z\": \"\", \"w\": []}",
- ExpectedError("Number".to_string(), "true".to_string()));
- check_err::<DecodeStruct>("{\"x\": 1, \"y\": [], \"z\": \"\", \"w\": []}",
- ExpectedError("Boolean".to_string(), "[]".to_string()));
- check_err::<DecodeStruct>("{\"x\": 1, \"y\": true, \"z\": {}, \"w\": []}",
- ExpectedError("String".to_string(), "{}".to_string()));
- check_err::<DecodeStruct>("{\"x\": 1, \"y\": true, \"z\": \"\", \"w\": null}",
- ExpectedError("Array".to_string(), "null".to_string()));
- check_err::<DecodeStruct>("{\"x\": 1, \"y\": true, \"z\": \"\"}",
- MissingFieldError("w".to_string()));
- }
- #[test]
- fn test_decode_errors_enum() {
- check_err::<DecodeEnum>("{}",
- MissingFieldError("variant".to_string()));
- check_err::<DecodeEnum>("{\"variant\": 1}",
- ExpectedError("String".to_string(), "1".to_string()));
- check_err::<DecodeEnum>("{\"variant\": \"A\"}",
- MissingFieldError("fields".to_string()));
- check_err::<DecodeEnum>("{\"variant\": \"A\", \"fields\": null}",
- ExpectedError("Array".to_string(), "null".to_string()));
- check_err::<DecodeEnum>("{\"variant\": \"C\", \"fields\": []}",
- UnknownVariantError("C".to_string()));
- }
-
- #[test]
- fn test_find(){
- let json_value = Json::from_str("{\"dog\" : \"cat\"}").unwrap();
- let found_str = json_value.find("dog");
- assert!(found_str.unwrap().as_string().unwrap() == "cat");
- }
-
- #[test]
- fn test_find_path(){
- let json_value = Json::from_str("{\"dog\":{\"cat\": {\"mouse\" : \"cheese\"}}}").unwrap();
- let found_str = json_value.find_path(&["dog", "cat", "mouse"]);
- assert!(found_str.unwrap().as_string().unwrap() == "cheese");
- }
-
- #[test]
- fn test_search(){
- let json_value = Json::from_str("{\"dog\":{\"cat\": {\"mouse\" : \"cheese\"}}}").unwrap();
- let found_str = json_value.search("mouse").and_then(|j| j.as_string());
- assert!(found_str.unwrap() == "cheese");
- }
-
- #[test]
- fn test_index(){
- let json_value = Json::from_str("{\"animals\":[\"dog\",\"cat\",\"mouse\"]}").unwrap();
- let ref array = json_value["animals"];
- assert_eq!(array[0].as_string().unwrap(), "dog");
- assert_eq!(array[1].as_string().unwrap(), "cat");
- assert_eq!(array[2].as_string().unwrap(), "mouse");
- }
-
- #[test]
- fn test_is_object(){
- let json_value = Json::from_str("{}").unwrap();
- assert!(json_value.is_object());
- }
-
- #[test]
- fn test_as_object(){
- let json_value = Json::from_str("{}").unwrap();
- let json_object = json_value.as_object();
- assert!(json_object.is_some());
- }
-
- #[test]
- fn test_is_array(){
- let json_value = Json::from_str("[1, 2, 3]").unwrap();
- assert!(json_value.is_array());
- }
-
- #[test]
- fn test_as_array(){
- let json_value = Json::from_str("[1, 2, 3]").unwrap();
- let json_array = json_value.as_array();
- let expected_length = 3;
- assert!(json_array.is_some() && json_array.unwrap().len() == expected_length);
- }
-
- #[test]
- fn test_is_string(){
- let json_value = Json::from_str("\"dog\"").unwrap();
- assert!(json_value.is_string());
- }
-
- #[test]
- fn test_as_string(){
- let json_value = Json::from_str("\"dog\"").unwrap();
- let json_str = json_value.as_string();
- let expected_str = "dog";
- assert_eq!(json_str, Some(expected_str));
- }
-
- #[test]
- fn test_is_number(){
- let json_value = Json::from_str("12").unwrap();
- assert!(json_value.is_number());
- }
-
- #[test]
- fn test_is_i64(){
- let json_value = Json::from_str("-12").unwrap();
- assert!(json_value.is_i64());
-
- let json_value = Json::from_str("12").unwrap();
- assert!(!json_value.is_i64());
-
- let json_value = Json::from_str("12.0").unwrap();
- assert!(!json_value.is_i64());
- }
-
- #[test]
- fn test_is_u64(){
- let json_value = Json::from_str("12").unwrap();
- assert!(json_value.is_u64());
-
- let json_value = Json::from_str("-12").unwrap();
- assert!(!json_value.is_u64());
-
- let json_value = Json::from_str("12.0").unwrap();
- assert!(!json_value.is_u64());
- }
-
- #[test]
- fn test_is_f64(){
- let json_value = Json::from_str("12").unwrap();
- assert!(!json_value.is_f64());
-
- let json_value = Json::from_str("-12").unwrap();
- assert!(!json_value.is_f64());
-
- let json_value = Json::from_str("12.0").unwrap();
- assert!(json_value.is_f64());
-
- let json_value = Json::from_str("-12.0").unwrap();
- assert!(json_value.is_f64());
- }
-
- #[test]
- fn test_as_i64(){
- let json_value = Json::from_str("-12").unwrap();
- let json_num = json_value.as_i64();
- assert_eq!(json_num, Some(-12));
- }
-
- #[test]
- fn test_as_u64(){
- let json_value = Json::from_str("12").unwrap();
- let json_num = json_value.as_u64();
- assert_eq!(json_num, Some(12));
- }
-
- #[test]
- fn test_as_f64(){
- let json_value = Json::from_str("12.0").unwrap();
- let json_num = json_value.as_f64();
- assert_eq!(json_num, Some(12f64));
- }
-
- #[test]
- fn test_is_boolean(){
- let json_value = Json::from_str("false").unwrap();
- assert!(json_value.is_boolean());
- }
-
- #[test]
- fn test_as_boolean(){
- let json_value = Json::from_str("false").unwrap();
- let json_bool = json_value.as_boolean();
- let expected_bool = false;
- assert!(json_bool.is_some() && json_bool.unwrap() == expected_bool);
- }
-
- #[test]
- fn test_is_null(){
- let json_value = Json::from_str("null").unwrap();
- assert!(json_value.is_null());
- }
-
- #[test]
- fn test_as_null(){
- let json_value = Json::from_str("null").unwrap();
- let json_null = json_value.as_null();
- let expected_null = ();
- assert!(json_null.is_some() && json_null.unwrap() == expected_null);
- }
-
- #[test]
- fn test_encode_hashmap_with_numeric_key() {
- use std::collections::HashMap;
- let mut hm: HashMap<usize, bool> = HashMap::new();
- hm.insert(1, true);
- let json_str = super::as_pretty_json(&hm).to_string();
- match Json::from_str(&json_str) {
- Err(_) => panic!("Unable to parse json_str: {}", json_str),
- _ => {} // it parsed and we are good to go
- }
- }
-
- #[test]
- fn test_negative_zero() {
- Json::from_str("{\"test\":-0}").unwrap();
- }
-
- #[test]
- fn test_prettyencode_hashmap_with_numeric_key() {
- use std::collections::HashMap;
- let mut hm: HashMap<usize, bool> = HashMap::new();
- hm.insert(1, true);
- let json_str = super::as_pretty_json(&hm).to_string();
- match Json::from_str(&json_str) {
- Err(_) => panic!("Unable to parse json_str: {}", json_str),
- _ => {} // it parsed and we are good to go
- }
- }
-
- #[test]
- fn test_prettyencoder_indent_level_param() {
- use std::collections::BTreeMap;
-
- let mut tree = BTreeMap::new();
-
- tree.insert("hello".to_string(), String("guten tag".to_string()));
- tree.insert("goodbye".to_string(), String("sayonara".to_string()));
-
- let json = Array(
- // The following layout below should look a lot like
- // the pretty-printed JSON (indent * x)
- vec!
- ( // 0x
- String("greetings".to_string()), // 1x
- Object(tree), // 1x + 2x + 2x + 1x
- ) // 0x
- // End JSON array (7 lines)
- );
-
- // Helper function for counting indents
- fn indents(source: &str) -> usize {
- let trimmed = source.trim_left_matches(' ');
- source.len() - trimmed.len()
- }
-
- // Test up to 4 spaces of indents (more?)
- for i in 0..4 {
- let printed = super::as_pretty_json(&json).indent(i as u32)
- .to_string();
-
- // Check for indents at each line
- let lines: Vec<&str> = printed.lines().collect();
- assert_eq!(lines.len(), 7); // JSON should be 7 lines
-
- assert_eq!(indents(lines[0]), 0 * i); // [
- assert_eq!(indents(lines[1]), 1 * i); // "greetings",
- assert_eq!(indents(lines[2]), 1 * i); // {
- assert_eq!(indents(lines[3]), 2 * i); // "hello": "guten tag",
- assert_eq!(indents(lines[4]), 2 * i); // "goodbye": "sayonara"
- assert_eq!(indents(lines[5]), 1 * i); // },
- assert_eq!(indents(lines[6]), 0 * i); // ]
-
- // Finally, test that the pretty-printed JSON is valid
- Json::from_str(&printed).ok()
- .expect("Pretty-printed JSON is invalid!");
- }
- }
-
- #[test]
- fn test_hashmap_with_numeric_key_can_handle_double_quote_delimited_key() {
- use std::collections::HashMap;
- use Decodable;
- let json_str = "{\"1\":true}";
- let json_obj = match Json::from_str(json_str) {
- Err(_) => panic!("Unable to parse json_str: {}", json_str),
- Ok(o) => o
- };
- let mut decoder = Decoder::new(json_obj);
- let _hm: HashMap<usize, bool> = Decodable::decode(&mut decoder).unwrap();
- }
-
- #[test]
- fn test_hashmap_with_enum_key() {
- use std::collections::HashMap;
- use json;
- #[derive(RustcEncodable, Eq, Hash, PartialEq, RustcDecodable, Debug)]
- enum Enum {
- Foo,
- #[allow(dead_code)]
- Bar,
- }
- let mut map = HashMap::new();
- map.insert(Enum::Foo, 0);
- let result = json::encode(&map).unwrap();
- assert_eq!(result, r#"{"Foo":0}"#);
- let decoded: HashMap<Enum, _> = json::decode(&result).unwrap();
- assert_eq!(map, decoded);
- }
-
- #[test]
- fn test_hashmap_with_numeric_key_will_error_with_string_keys() {
- use std::collections::HashMap;
- use Decodable;
- let json_str = "{\"a\":true}";
- let json_obj = match Json::from_str(json_str) {
- Err(_) => panic!("Unable to parse json_str: {}", json_str),
- Ok(o) => o
- };
- let mut decoder = Decoder::new(json_obj);
- let result: Result<HashMap<usize, bool>, DecoderError> = Decodable::decode(&mut decoder);
- assert_eq!(result, Err(ExpectedError("Number".to_string(), "a".to_string())));
- }
-
- fn assert_stream_equal(src: &str,
- expected: Vec<(JsonEvent, Vec<StackElement>)>) {
- let mut parser = Parser::new(src.chars());
- let mut i = 0;
- loop {
- let evt = match parser.next() {
- Some(e) => e,
- None => { break; }
- };
- let (ref expected_evt, ref expected_stack) = expected[i];
- if !parser.stack().is_equal_to(&expected_stack) {
- panic!("Parser stack is not equal to {:?}", expected_stack);
- }
- assert_eq!(&evt, expected_evt);
- i+=1;
- }
- }
- #[test]
- #[cfg_attr(target_word_size = "32", ignore)] // FIXME(#14064)
- fn test_streaming_parser() {
- assert_stream_equal(
- r#"{ "foo":"bar", "array" : [0, 1, 2, 3, 4, 5], "idents":[null,true,false]}"#,
- vec![
- (ObjectStart, vec![]),
- (StringValue("bar".to_string()), vec![Key("foo")]),
- (ArrayStart, vec![Key("array")]),
- (U64Value(0), vec![Key("array"), Index(0)]),
- (U64Value(1), vec![Key("array"), Index(1)]),
- (U64Value(2), vec![Key("array"), Index(2)]),
- (U64Value(3), vec![Key("array"), Index(3)]),
- (U64Value(4), vec![Key("array"), Index(4)]),
- (U64Value(5), vec![Key("array"), Index(5)]),
- (ArrayEnd, vec![Key("array")]),
- (ArrayStart, vec![Key("idents")]),
- (NullValue, vec![Key("idents"), Index(0)]),
- (BooleanValue(true), vec![Key("idents"), Index(1)]),
- (BooleanValue(false), vec![Key("idents"), Index(2)]),
- (ArrayEnd, vec![Key("idents")]),
- (ObjectEnd, vec![]),
- ]
- );
- }
- fn last_event(src: &str) -> JsonEvent {
- let mut parser = Parser::new(src.chars());
- let mut evt = NullValue;
- loop {
- evt = match parser.next() {
- Some(e) => e,
- None => return evt,
- }
- }
- }
-
- #[test]
- #[cfg_attr(target_word_size = "32", ignore)] // FIXME(#14064)
- fn test_read_object_streaming() {
- assert_eq!(last_event("{ "), Error(SyntaxError(EOFWhileParsingObject, 1, 3)));
- assert_eq!(last_event("{1"), Error(SyntaxError(KeyMustBeAString, 1, 2)));
- assert_eq!(last_event("{ \"a\""), Error(SyntaxError(EOFWhileParsingObject, 1, 6)));
- assert_eq!(last_event("{\"a\""), Error(SyntaxError(EOFWhileParsingObject, 1, 5)));
- assert_eq!(last_event("{\"a\" "), Error(SyntaxError(EOFWhileParsingObject, 1, 6)));
-
- assert_eq!(last_event("{\"a\" 1"), Error(SyntaxError(ExpectedColon, 1, 6)));
- assert_eq!(last_event("{\"a\":"), Error(SyntaxError(EOFWhileParsingValue, 1, 6)));
- assert_eq!(last_event("{\"a\":1"), Error(SyntaxError(EOFWhileParsingObject, 1, 7)));
- assert_eq!(last_event("{\"a\":1 1"), Error(SyntaxError(InvalidSyntax, 1, 8)));
- assert_eq!(last_event("{\"a\":1,"), Error(SyntaxError(EOFWhileParsingObject, 1, 8)));
- assert_eq!(last_event("{\"a\":1,}"), Error(SyntaxError(TrailingComma, 1, 8)));
-
- assert_stream_equal(
- "{}",
- vec![(ObjectStart, vec![]), (ObjectEnd, vec![])]
- );
- assert_stream_equal(
- "{\"a\": 3}",
- vec![
- (ObjectStart, vec![]),
- (U64Value(3), vec![Key("a")]),
- (ObjectEnd, vec![]),
- ]
- );
- assert_stream_equal(
- "{ \"a\": null, \"b\" : true }",
- vec![
- (ObjectStart, vec![]),
- (NullValue, vec![Key("a")]),
- (BooleanValue(true), vec![Key("b")]),
- (ObjectEnd, vec![]),
- ]
- );
- assert_stream_equal(
- "{\"a\" : 1.0 ,\"b\": [ true ]}",
- vec![
- (ObjectStart, vec![]),
- (F64Value(1.0), vec![Key("a")]),
- (ArrayStart, vec![Key("b")]),
- (BooleanValue(true),vec![Key("b"), Index(0)]),
- (ArrayEnd, vec![Key("b")]),
- (ObjectEnd, vec![]),
- ]
- );
- assert_stream_equal(
- r#"{
- "a": 1.0,
- "b": [
- true,
- "foo\nbar",
- { "c": {"d": null} },
- "\uD834\uDF06"
- ]
- }"#,
- vec![
- (ObjectStart, vec![]),
- (F64Value(1.0), vec![Key("a")]),
- (ArrayStart, vec![Key("b")]),
- (BooleanValue(true), vec![Key("b"), Index(0)]),
- (StringValue("foo\nbar".to_string()), vec![Key("b"), Index(1)]),
- (ObjectStart, vec![Key("b"), Index(2)]),
- (ObjectStart, vec![Key("b"), Index(2), Key("c")]),
- (NullValue, vec![Key("b"), Index(2), Key("c"), Key("d")]),
- (ObjectEnd, vec![Key("b"), Index(2), Key("c")]),
- (ObjectEnd, vec![Key("b"), Index(2)]),
- (StringValue("\u{1D306}".to_string()), vec![Key("b"), Index(3)]),
- (ArrayEnd, vec![Key("b")]),
- (ObjectEnd, vec![]),
- ]
- );
- }
- #[test]
- #[cfg_attr(target_word_size = "32", ignore)] // FIXME(#14064)
- fn test_read_array_streaming() {
- assert_stream_equal(
- "[]",
- vec![
- (ArrayStart, vec![]),
- (ArrayEnd, vec![]),
- ]
- );
- assert_stream_equal(
- "[ ]",
- vec![
- (ArrayStart, vec![]),
- (ArrayEnd, vec![]),
- ]
- );
- assert_stream_equal(
- "[true]",
- vec![
- (ArrayStart, vec![]),
- (BooleanValue(true), vec![Index(0)]),
- (ArrayEnd, vec![]),
- ]
- );
- assert_stream_equal(
- "[ false ]",
- vec![
- (ArrayStart, vec![]),
- (BooleanValue(false), vec![Index(0)]),
- (ArrayEnd, vec![]),
- ]
- );
- assert_stream_equal(
- "[null]",
- vec![
- (ArrayStart, vec![]),
- (NullValue, vec![Index(0)]),
- (ArrayEnd, vec![]),
- ]
- );
- assert_stream_equal(
- "[3, 1]",
- vec![
- (ArrayStart, vec![]),
- (U64Value(3), vec![Index(0)]),
- (U64Value(1), vec![Index(1)]),
- (ArrayEnd, vec![]),
- ]
- );
- assert_stream_equal(
- "\n[3, 2]\n",
- vec![
- (ArrayStart, vec![]),
- (U64Value(3), vec![Index(0)]),
- (U64Value(2), vec![Index(1)]),
- (ArrayEnd, vec![]),
- ]
- );
- assert_stream_equal(
- "[2, [4, 1]]",
- vec![
- (ArrayStart, vec![]),
- (U64Value(2), vec![Index(0)]),
- (ArrayStart, vec![Index(1)]),
- (U64Value(4), vec![Index(1), Index(0)]),
- (U64Value(1), vec![Index(1), Index(1)]),
- (ArrayEnd, vec![Index(1)]),
- (ArrayEnd, vec![]),
- ]
- );
-
- assert_eq!(last_event("["), Error(SyntaxError(EOFWhileParsingValue, 1, 2)));
-
- assert_eq!(Json::from_str("["), Err(SyntaxError(EOFWhileParsingValue, 1, 2)));
- assert_eq!(Json::from_str("[1"), Err(SyntaxError(EOFWhileParsingArray, 1, 3)));
- assert_eq!(Json::from_str("[1,"), Err(SyntaxError(EOFWhileParsingValue, 1, 4)));
- assert_eq!(Json::from_str("[1,]"), Err(SyntaxError(InvalidSyntax, 1, 4)));
- assert_eq!(Json::from_str("[6 7]"), Err(SyntaxError(InvalidSyntax, 1, 4)));
-
- }
- #[test]
- fn test_trailing_characters_streaming() {
- assert_eq!(last_event("nulla"), Error(SyntaxError(TrailingCharacters, 1, 5)));
- assert_eq!(last_event("truea"), Error(SyntaxError(TrailingCharacters, 1, 5)));
- assert_eq!(last_event("falsea"), Error(SyntaxError(TrailingCharacters, 1, 6)));
- assert_eq!(last_event("1a"), Error(SyntaxError(TrailingCharacters, 1, 2)));
- assert_eq!(last_event("[]a"), Error(SyntaxError(TrailingCharacters, 1, 3)));
- assert_eq!(last_event("{}a"), Error(SyntaxError(TrailingCharacters, 1, 3)));
- }
- #[test]
- fn test_read_identifiers_streaming() {
- assert_eq!(Parser::new("null".chars()).next(), Some(NullValue));
- assert_eq!(Parser::new("true".chars()).next(), Some(BooleanValue(true)));
- assert_eq!(Parser::new("false".chars()).next(), Some(BooleanValue(false)));
-
- assert_eq!(last_event("n"), Error(SyntaxError(InvalidSyntax, 1, 2)));
- assert_eq!(last_event("nul"), Error(SyntaxError(InvalidSyntax, 1, 4)));
- assert_eq!(last_event("t"), Error(SyntaxError(InvalidSyntax, 1, 2)));
- assert_eq!(last_event("truz"), Error(SyntaxError(InvalidSyntax, 1, 4)));
- assert_eq!(last_event("f"), Error(SyntaxError(InvalidSyntax, 1, 2)));
- assert_eq!(last_event("faz"), Error(SyntaxError(InvalidSyntax, 1, 3)));
- }
-
- #[test]
- fn test_stack() {
- let mut stack = Stack::new();
-
- assert!(stack.is_empty());
- assert!(stack.len() == 0);
- assert!(!stack.last_is_index());
-
- stack.push_index(0);
- stack.bump_index();
-
- assert!(stack.len() == 1);
- assert!(stack.is_equal_to(&[Index(1)]));
- assert!(stack.starts_with(&[Index(1)]));
- assert!(stack.ends_with(&[Index(1)]));
- assert!(stack.last_is_index());
- assert!(stack.get(0) == Index(1));
-
- stack.push_key("foo".to_string());
-
- assert!(stack.len() == 2);
- assert!(stack.is_equal_to(&[Index(1), Key("foo")]));
- assert!(stack.starts_with(&[Index(1), Key("foo")]));
- assert!(stack.starts_with(&[Index(1)]));
- assert!(stack.ends_with(&[Index(1), Key("foo")]));
- assert!(stack.ends_with(&[Key("foo")]));
- assert!(!stack.last_is_index());
- assert!(stack.get(0) == Index(1));
- assert!(stack.get(1) == Key("foo"));
-
- stack.push_key("bar".to_string());
-
- assert!(stack.len() == 3);
- assert!(stack.is_equal_to(&[Index(1), Key("foo"), Key("bar")]));
- assert!(stack.starts_with(&[Index(1)]));
- assert!(stack.starts_with(&[Index(1), Key("foo")]));
- assert!(stack.starts_with(&[Index(1), Key("foo"), Key("bar")]));
- assert!(stack.ends_with(&[Key("bar")]));
- assert!(stack.ends_with(&[Key("foo"), Key("bar")]));
- assert!(stack.ends_with(&[Index(1), Key("foo"), Key("bar")]));
- assert!(!stack.last_is_index());
- assert!(stack.get(0) == Index(1));
- assert!(stack.get(1) == Key("foo"));
- assert!(stack.get(2) == Key("bar"));
-
- stack.pop();
-
- assert!(stack.len() == 2);
- assert!(stack.is_equal_to(&[Index(1), Key("foo")]));
- assert!(stack.starts_with(&[Index(1), Key("foo")]));
- assert!(stack.starts_with(&[Index(1)]));
- assert!(stack.ends_with(&[Index(1), Key("foo")]));
- assert!(stack.ends_with(&[Key("foo")]));
- assert!(!stack.last_is_index());
- assert!(stack.get(0) == Index(1));
- assert!(stack.get(1) == Key("foo"));
- }
-
- #[test]
- fn test_to_json() {
- use std::collections::{HashMap,BTreeMap};
- use super::ToJson;
-
- let array2 = Array(vec!(I64(1), I64(2)));
- let array3 = Array(vec!(I64(1), I64(2), I64(3)));
- let object = {
- let mut tree_map = BTreeMap::new();
- tree_map.insert("a".to_string(), U64(1));
- tree_map.insert("b".to_string(), U64(2));
- Object(tree_map)
- };
-
- assert_eq!(array2.to_json(), array2);
- assert_eq!(object.to_json(), object);
- assert_eq!(3_isize.to_json(), I64(3));
- assert_eq!(4_i8.to_json(), I64(4));
- assert_eq!(5_i16.to_json(), I64(5));
- assert_eq!(6_i32.to_json(), I64(6));
- assert_eq!(7_i64.to_json(), I64(7));
- assert_eq!(8_usize.to_json(), U64(8));
- assert_eq!(9_u8.to_json(), U64(9));
- assert_eq!(10_u16.to_json(), U64(10));
- assert_eq!(11_u32.to_json(), U64(11));
- assert_eq!(12_u64.to_json(), U64(12));
- assert_eq!(13.0_f32.to_json(), F64(13.0_f64));
- assert_eq!(14.0_f64.to_json(), F64(14.0_f64));
- assert_eq!(().to_json(), Null);
- assert_eq!(f32::INFINITY.to_json(), Null);
- assert_eq!(f64::NAN.to_json(), Null);
- assert_eq!(true.to_json(), Boolean(true));
- assert_eq!(false.to_json(), Boolean(false));
- assert_eq!("abc".to_json(), String("abc".to_string()));
- assert_eq!("abc".to_string().to_json(), String("abc".to_string()));
- assert_eq!((1, 2).to_json(), array2);
- assert_eq!((1, 2, 3).to_json(), array3);
- assert_eq!([1, 2].to_json(), array2);
- assert_eq!((&[1, 2, 3]).to_json(), array3);
- assert_eq!((vec![1, 2]).to_json(), array2);
- assert_eq!(vec!(1, 2, 3).to_json(), array3);
- let mut tree_map = BTreeMap::new();
- tree_map.insert("a".to_string(), 1 as u32);
- tree_map.insert("b".to_string(), 2);
- assert_eq!(tree_map.to_json(), object);
- let mut hash_map = HashMap::new();
- hash_map.insert("a".to_string(), 1 as u32);
- hash_map.insert("b".to_string(), 2);
- assert_eq!(hash_map.to_json(), object);
- assert_eq!(Some(15).to_json(), I64(15));
- assert_eq!(Some(15 as u32).to_json(), U64(15));
- assert_eq!(None::<isize>.to_json(), Null);
- }
-
- #[test]
- fn test_encode_hashmap_with_arbitrary_key() {
- use std::collections::HashMap;
- #[derive(PartialEq, Eq, Hash, RustcEncodable)]
- struct ArbitraryType(u32);
- let mut hm: HashMap<ArbitraryType, bool> = HashMap::new();
- hm.insert(ArbitraryType(1), true);
- let mut mem_buf = string::String::new();
- let mut encoder = Encoder::new(&mut mem_buf);
- let result = hm.encode(&mut encoder);
- match result.err().unwrap() {
- EncoderError::BadHashmapKey => (),
- _ => panic!("expected bad hash map key")
- }
- }
-
- #[test]
- fn test_encode_decode_phantom_data() {
- use std::marker::PhantomData;
-
- #[derive(Debug, RustcDecodable, RustcEncodable, Eq, PartialEq)]
- struct Foo<P> {
- phantom_data: PhantomData<P>
- }
-
- let f: Foo<u8> = Foo {
- phantom_data: PhantomData
- };
- let s = super::encode(&f).unwrap();
- let d: Foo<u8> = super::decode(&s).unwrap();
- assert_eq!(f, d);
- }
-
- #[test]
- fn test_bad_json_stack_depleted() {
- use json;
- #[derive(Debug, RustcDecodable)]
- enum ChatEvent {
- Variant(i32)
- }
- let serialized = "{\"variant\": \"Variant\", \"fields\": []}";
- let r: Result<ChatEvent, _> = json::decode(serialized);
- assert!(r.unwrap_err() == EOF);
- }
-
- #[test]
- fn fixed_length_array() {
- #[derive(Debug, RustcDecodable, RustcEncodable, Eq, PartialEq)]
- struct Foo {
- a: [u8; 1],
- b: [i32; 2],
- c: [u64; 3],
- }
- let f = Foo {
- a: [0],
- b: [1, 2],
- c: [3, 4, 5],
- };
- let s = super::encode(&f).unwrap();
- let d = super::decode(&s).unwrap();
- assert_eq!(f, d);
- }
-
- #[test]
- fn test_unexpected_token() {
- match Json::from_str("{\"\":\"\",\"\":{\"\":\"\",\"\":[{\"\":\"\",}}}") {
- Err(e) => assert_eq!(e, SyntaxError(InvalidSyntax, 1, 32)),
- _ => ()
- };
- }
-}
deleted file mode 100644
--- a/third_party/rust/rustc-serialize/src/lib.rs
+++ /dev/null
@@ -1,79 +0,0 @@
-// Copyright 2012-2014 The Rust Project Developers. See the COPYRIGHT
-// file at the top-level directory of this distribution and at
-// http://rust-lang.org/COPYRIGHT.
-//
-// Licensed under the Apache License, Version 2.0 <LICENSE-APACHE or
-// http://www.apache.org/licenses/LICENSE-2.0> or the MIT license
-// <LICENSE-MIT or http://opensource.org/licenses/MIT>, at your
-// option. This file may not be copied, modified, or distributed
-// except according to those terms.
-
-//! Support code for encoding and decoding types.
-//!
-//! > **NOTE**: This crate is deprecated in favor of [`serde`]. No new feature
-//! > development will happen in this crate, although bug fixes proposed through
-//! > PRs will still be merged. It is very highly recommended by the Rust
-//! > Library Team that you use [`serde`], not this crate.
-//!
-//! [`serde`]: https://serde.rs
-//!
-//! # Usage
-//!
-//! This crate is [on crates.io](https://crates.io/crates/rustc-serialize) and
-//! can be used by adding `rustc-serialize` to the dependencies in your
-//! project's `Cargo.toml`.
-//!
-//! ```toml
-//! [dependencies]
-//! rustc-serialize = "0.3"
-//! ```
-//!
-//! and this to your crate root:
-//!
-//! ```rust
-//! extern crate rustc_serialize;
-//! ```
-
-#![cfg_attr(rustbuild, feature(staged_api, rustc_private))]
-#![cfg_attr(rustbuild, unstable(feature = "rustc_private", issue = "27812"))]
-
-#![doc(html_logo_url = "https://www.rust-lang.org/logos/rust-logo-128x128-blk-v2.png",
- html_favicon_url = "https://www.rust-lang.org/favicon.ico",
- html_root_url = "https://doc.rust-lang.org/rustc-serialize/")]
-#![cfg_attr(test, deny(warnings))]
-#![allow(trivial_numeric_casts)]
-#![cfg_attr(rust_build, feature(staged_api))]
-#![cfg_attr(rust_build, staged_api)]
-#![cfg_attr(rust_build,
- unstable(feature = "rustc_private",
- reason = "use the crates.io `rustc-serialize` library instead"))]
-
-#[cfg(test)] extern crate rand;
-
-pub use self::serialize::{Decoder, Encoder, Decodable, Encodable,
- DecoderHelpers, EncoderHelpers};
-
-
-// Limit collections from allocating more than
-// 1 MB for calls to `with_capacity`.
-fn cap_capacity<T>(given_len: usize) -> usize {
- use std::cmp::min;
- use std::mem::size_of;
- const PRE_ALLOCATE_CAP: usize = 0x100000;
-
- match size_of::<T>() {
- 0 => min(given_len, PRE_ALLOCATE_CAP),
- n => min(given_len, PRE_ALLOCATE_CAP / n)
- }
-}
-
-mod serialize;
-mod collection_impls;
-
-pub mod base64;
-pub mod hex;
-pub mod json;
-
-mod rustc_serialize {
- pub use serialize::*;
-}
deleted file mode 100644
--- a/third_party/rust/rustc-serialize/src/serialize.rs
+++ /dev/null
@@ -1,1671 +0,0 @@
-// Copyright 2012-2014 The Rust Project Developers. See the COPYRIGHT
-// file at the top-level directory of this distribution and at
-// http://rust-lang.org/COPYRIGHT.
-//
-// Licensed under the Apache License, Version 2.0 <LICENSE-APACHE or
-// http://www.apache.org/licenses/LICENSE-2.0> or the MIT license
-// <LICENSE-MIT or http://opensource.org/licenses/MIT>, at your
-// option. This file may not be copied, modified, or distributed
-// except according to those terms.
-
-//! Support code for encoding and decoding types.
-//!
-//! In order to allow extensibility in both what types can be encoded and how
-//! they are encoded, encoding and decoding are split into two part each. An
-//! implementation of the Encodable trait knows how to turn a specific type into
-//! a generic form, and then uses an implementation of the Encoder trait to turn
-//! this into concrete output (such as a JSON string). Decoder and Decodable do
-//! the same for decoding.
-
-/*
-Core encoding and decoding interfaces.
-*/
-
-use std::cell::{Cell, RefCell};
-use std::ffi::OsString;
-use std::path;
-use std::rc::Rc;
-use std::sync::Arc;
-use std::marker::PhantomData;
-use std::borrow::Cow;
-
-use cap_capacity;
-
-/// Trait for writing out an encoding when serializing.
-///
-/// This trait provides methods to encode basic types and generic forms of
-/// collections. Implementations of `Encodable` use it to perform the actual
-/// encoding of a type.
-///
-/// It is unspecified what is done with the encoding - it could be stored in a
-/// variable, or written directly to a file, for example.
-///
-/// Encoders can expect to only have a single "root" method call made on this
-/// trait. Non-trivial types will call one of the collection-emitting methods,
-/// passing a function that may call other methods on the trait, but once the
-/// collection-emitting method has returned, encoding should be complete.
-pub trait Encoder {
- /// The error type for method results.
- type Error;
-
- // Primitive types:
- /// Emit a nil value.
- ///
- /// For example, this might be stored as the null keyword in JSON.
- fn emit_nil(&mut self) -> Result<(), Self::Error>;
-
- /// Emit a usize value.
- fn emit_usize(&mut self, v: usize) -> Result<(), Self::Error>;
-
- /// Emit a u64 value.
- fn emit_u64(&mut self, v: u64) -> Result<(), Self::Error>;
-
- /// Emit a u32 value.
- fn emit_u32(&mut self, v: u32) -> Result<(), Self::Error>;
-
- /// Emit a u16 value.
- fn emit_u16(&mut self, v: u16) -> Result<(), Self::Error>;
-
- /// Emit a u8 value.
- fn emit_u8(&mut self, v: u8) -> Result<(), Self::Error>;
-
- /// Emit a isize value.
- fn emit_isize(&mut self, v: isize) -> Result<(), Self::Error>;
-
- /// Emit a i64 value.
- fn emit_i64(&mut self, v: i64) -> Result<(), Self::Error>;
-
- /// Emit a i32 value.
- fn emit_i32(&mut self, v: i32) -> Result<(), Self::Error>;
-
- /// Emit a i16 value.
- fn emit_i16(&mut self, v: i16) -> Result<(), Self::Error>;
-
- /// Emit a i8 value.
- fn emit_i8(&mut self, v: i8) -> Result<(), Self::Error>;
-
- /// Emit a bool value.
- ///
- /// For example, this might be stored as the true and false keywords in
- /// JSON.
- fn emit_bool(&mut self, v: bool) -> Result<(), Self::Error>;
-
- /// Emit a f64 value.
- fn emit_f64(&mut self, v: f64) -> Result<(), Self::Error>;
-
- /// Emit a f32 value.
- fn emit_f32(&mut self, v: f32) -> Result<(), Self::Error>;
-
- /// Emit a char value.
- ///
- /// Note that strings should be emitted using `emit_str`, not as a sequence
- /// of `emit_char` calls.
- fn emit_char(&mut self, v: char) -> Result<(), Self::Error>;
-
- /// Emit a string value.
- fn emit_str(&mut self, v: &str) -> Result<(), Self::Error>;
-
- // Compound types:
- /// Emit an enumeration value.
- ///
- /// * `name` indicates the enumeration type name.
- /// * `f` is a function that will call `emit_enum_variant` or
- /// `emit_enum_struct_variant` as appropriate to write the actual value.
- fn emit_enum<F>(&mut self, name: &str, f: F) -> Result<(), Self::Error>
- where F: FnOnce(&mut Self) -> Result<(), Self::Error>;
-
- /// Emit a enumeration variant value with no or unnamed data.
- ///
- /// This should only be called from a function passed to `emit_enum`.
- /// Variants with named data should use `emit_enum_struct_variant`.
- ///
- /// * `v_name` is the variant name
- /// * `v_id` is the numeric identifier for the variant.
- /// * `len` is the number of data items associated with the variant.
- /// * `f` is a function that will call `emit_enum_variant_arg` for each data
- /// item. It may not be called if len is 0.
- ///
- /// # Examples
- ///
- /// ```
- /// use rustc_serialize::Encodable;
- /// use rustc_serialize::Encoder;
- ///
- /// enum Message {
- /// Quit,
- /// ChangeColor(i32, i32, i32),
- /// }
- ///
- /// impl Encodable for Message {
- /// fn encode<S: Encoder>(&self, s: &mut S) -> Result<(), S::Error> {
- /// s.emit_enum("Message", |s| {
- /// match *self {
- /// Message::Quit => {
- /// s.emit_enum_variant("Quit", 0, 0, |s| Ok(()))
- /// }
- /// Message::ChangeColor(r, g, b) => {
- /// s.emit_enum_variant("ChangeColor", 1, 3, |s| {
- /// try!(s.emit_enum_variant_arg(0, |s| {
- /// s.emit_i32(r)
- /// }));
- /// try!(s.emit_enum_variant_arg(1, |s| {
- /// s.emit_i32(g)
- /// }));
- /// try!(s.emit_enum_variant_arg(2, |s| {
- /// s.emit_i32(b)
- /// }));
- /// Ok(())
- /// })
- /// }
- /// }
- /// })
- /// }
- /// }
- /// ```
- fn emit_enum_variant<F>(&mut self, v_name: &str,
- v_id: usize,
- len: usize,
- f: F) -> Result<(), Self::Error>
- where F: FnOnce(&mut Self) -> Result<(), Self::Error>;
-
- /// Emit an unnamed data item for an enumeration variant.
- ///
- /// This should only be called from a function passed to
- /// `emit_enum_variant`.
- ///
- /// * `a_idx` is the (zero-based) index of the data item.
- /// * `f` is a function that will call the appropriate emit method to encode
- /// the data object.
- ///
- /// Note that variant data items must be emitted in order - starting with
- /// index `0` and finishing with index `len-1`.
- fn emit_enum_variant_arg<F>(&mut self, a_idx: usize, f: F)
- -> Result<(), Self::Error>
- where F: FnOnce(&mut Self) -> Result<(), Self::Error>;
-
- /// Emit a enumeration variant value with no or named data.
- ///
- /// This should only be called from a function passed to `emit_enum`.
- /// Variants with unnamed data should use `emit_enum_variant`.
- ///
- /// * `v_name` is the variant name.
- /// * `v_id` is the numeric identifier for the variant.
- /// * `len` is the number of data items associated with the variant.
- /// * `f` is a function that will call `emit_enum_struct_variant_field` for
- /// each data item. It may not be called if `len` is `0`.
- ///
- /// # Examples
- ///
- /// ```
- /// use rustc_serialize::Encodable;
- /// use rustc_serialize::Encoder;
- ///
- /// enum Message {
- /// Quit,
- /// Move { x: i32, y: i32 },
- /// }
- ///
- /// impl Encodable for Message {
- /// fn encode<S: Encoder>(&self, s: &mut S) -> Result<(), S::Error> {
- /// s.emit_enum("Message", |s| {
- /// match *self {
- /// Message::Quit => {
- /// s.emit_enum_struct_variant("Quit", 0, 0, |s| Ok(()))
- /// }
- /// Message::Move { x: x, y: y } => {
- /// s.emit_enum_struct_variant("Move", 1, 2, |s| {
- /// try!(s.emit_enum_struct_variant_field("x", 0, |s| {
- /// s.emit_i32(x)
- /// }));
- /// try!(s.emit_enum_struct_variant_field("y", 1, |s| {
- /// s.emit_i32(y)
- /// }));
- /// Ok(())
- /// })
- /// }
- /// }
- /// })
- /// }
- /// }
- /// ```
- fn emit_enum_struct_variant<F>(&mut self, v_name: &str,
- v_id: usize,
- len: usize,
- f: F) -> Result<(), Self::Error>
- where F: FnOnce(&mut Self) -> Result<(), Self::Error>;
-
- /// Emit a named data item for an enumeration variant.
- ///
- /// This should only be called from a function passed to
- /// `emit_enum_struct_variant`.
- ///
- /// * `f_name` is the name of the data item field.
- /// * `f_idx` is its (zero-based) index.
- /// * `f` is a function that will call the appropriate emit method to encode
- /// the data object.
- ///
- /// Note that fields must be emitted in order - starting with index `0` and
- /// finishing with index `len-1`.
- fn emit_enum_struct_variant_field<F>(&mut self,
- f_name: &str,
- f_idx: usize,
- f: F) -> Result<(), Self::Error>
- where F: FnOnce(&mut Self) -> Result<(), Self::Error>;
-
- /// Emit a struct value.
- ///
- /// * `name` is the name of the struct.
- /// * `len` is the number of members.
- /// * `f` is a function that calls `emit_struct_field` for each member.
- ///
- /// # Examples
- ///
- /// ```
- /// use rustc_serialize::Encodable;
- /// use rustc_serialize::Encoder;
- ///
- /// struct Point {
- /// x: i32,
- /// y: i32,
- /// }
- ///
- /// impl Encodable for Point {
- /// fn encode<S: Encoder>(&self, s: &mut S) -> Result<(), S::Error> {
- /// s.emit_struct("Point", 2, |s| {
- /// try!(s.emit_struct_field("x", 0, |s| {
- /// s.emit_i32(self.x)
- /// }));
- /// try!(s.emit_struct_field("y", 1, |s| {
- /// s.emit_i32(self.y)
- /// }));
- /// Ok(())
- /// })
- /// }
- /// }
- /// ```
- fn emit_struct<F>(&mut self, name: &str, len: usize, f: F)
- -> Result<(), Self::Error>
- where F: FnOnce(&mut Self) -> Result<(), Self::Error>;
- /// Emit a field item for a struct.
- ///
- /// This should only be called from a function passed to `emit_struct`.
- ///
- /// * `f_name` is the name of the data item field.
- /// * `f_idx` is its (zero-based) index.
- /// * `f` is a function that will call the appropriate emit method to encode
- /// the data object.
- ///
- /// Note that fields must be emitted in order - starting with index `0` and
- /// finishing with index `len-1`.
- fn emit_struct_field<F>(&mut self, f_name: &str, f_idx: usize, f: F)
- -> Result<(), Self::Error>
- where F: FnOnce(&mut Self) -> Result<(), Self::Error>;
-
- /// Emit a tuple value.
- ///
- /// * `len` is the number of items in the tuple.
- /// * `f` is a function that calls `emit_tuple_arg` for each member.
- ///
- /// Note that external `Encodable` implementations should not normally need
- /// to use this method directly; it is meant for the use of this module's
- /// own implementation of `Encodable` for tuples.
- fn emit_tuple<F>(&mut self, len: usize, f: F) -> Result<(), Self::Error>
- where F: FnOnce(&mut Self) -> Result<(), Self::Error>;
-
- /// Emit a data item for a tuple.
- ///
- /// This should only be called from a function passed to `emit_tuple`.
- ///
- /// * `idx` is the (zero-based) index of the data item.
- /// * `f` is a function that will call the appropriate emit method to encode
- /// the data object.
- ///
- /// Note that tuple items must be emitted in order - starting with index `0`
- /// and finishing with index `len-1`.
- fn emit_tuple_arg<F>(&mut self, idx: usize, f: F) -> Result<(), Self::Error>
- where F: FnOnce(&mut Self) -> Result<(), Self::Error>;
-
- /// Emit a tuple struct value.
- ///
- /// * `name` is the name of the tuple struct.
- /// * `len` is the number of items in the tuple struct.
- /// * `f` is a function that calls `emit_tuple_struct_arg` for each member.
- ///
- /// # Examples
- ///
- /// ```
- /// use rustc_serialize::Encodable;
- /// use rustc_serialize::Encoder;
- ///
- /// struct Pair(i32,i32);
- ///
- /// impl Encodable for Pair {
- /// fn encode<S: Encoder>(&self, s: &mut S) -> Result<(), S::Error> {
- /// let Pair(first,second) = *self;
- /// s.emit_tuple_struct("Pair", 2, |s| {
- /// try!(s.emit_tuple_arg(0, |s| {
- /// s.emit_i32(first)
- /// }));
- /// try!(s.emit_tuple_arg(1, |s| {
- /// s.emit_i32(second)
- /// }));
- /// Ok(())
- /// })
- /// }
- /// }
- /// ```
- fn emit_tuple_struct<F>(&mut self, name: &str, len: usize, f: F)
- -> Result<(), Self::Error>
- where F: FnOnce(&mut Self) -> Result<(), Self::Error>;
-
- /// Emit a data item for a tuple struct.
- ///
- /// This should only be called from a function passed to
- /// `emit_tuple_struct`.
- ///
- /// * `f_idx` is the (zero-based) index of the data item.
- /// * `f` is a function that will call the appropriate emit method to encode
- /// the data object.
- ///
- /// Note that tuple items must be emitted in order - starting with index `0`
- /// and finishing with index `len-1`.
- fn emit_tuple_struct_arg<F>(&mut self, f_idx: usize, f: F)
- -> Result<(), Self::Error>
- where F: FnOnce(&mut Self) -> Result<(), Self::Error>;
-
- // Specialized types:
- /// Emit an optional value.
- ///
- /// `f` is a function that will call either `emit_option_none` or
- /// `emit_option_some` as appropriate.
- ///
- /// This method allows encoders to handle `Option<T>` values specially,
- /// rather than using the generic enum methods, because many encoding
- /// formats have a built-in "optional" concept.
- ///
- /// Note that external `Encodable` implementations should not normally need
- /// to use this method directly; it is meant for the use of this module's
- /// own implementation of `Encodable` for `Option<T>`.
- fn emit_option<F>(&mut self, f: F) -> Result<(), Self::Error>
- where F: FnOnce(&mut Self) -> Result<(), Self::Error>;
-
- /// Emit the `None` optional value.
- ///
- /// This should only be called from a function passed to `emit_option`.
- fn emit_option_none(&mut self) -> Result<(), Self::Error>;
-
- /// Emit the `Some(x)` optional value.
- ///
- /// `f` is a function that will call the appropriate emit method to encode
- /// the data object.
- ///
- /// This should only be called from a function passed to `emit_option`.
- fn emit_option_some<F>(&mut self, f: F) -> Result<(), Self::Error>
- where F: FnOnce(&mut Self) -> Result<(), Self::Error>;
-
- /// Emit a sequence of values.
- ///
- /// This should be used for both array-like ordered sequences and set-like
- /// unordered ones.
- ///
- /// * `len` is the number of values in the sequence.
- /// * `f` is a function that will call `emit_seq_elt` for each value in the
- /// sequence.
- fn emit_seq<F>(&mut self, len: usize, f: F) -> Result<(), Self::Error>
- where F: FnOnce(&mut Self) -> Result<(), Self::Error>;
-
- /// Emit an element in a sequence.
- ///
- /// This should only be called from a function passed to `emit_seq`.
- ///
- /// * `idx` is the (zero-based) index of the value in the sequence.
- /// * `f` is a function that will call the appropriate emit method to encode
- /// the data object.
- ///
- /// Note that sequence elements must be emitted in order - starting with
- /// index `0` and finishing with index `len-1`.
- fn emit_seq_elt<F>(&mut self, idx: usize, f: F) -> Result<(), Self::Error>
- where F: FnOnce(&mut Self) -> Result<(), Self::Error>;
-
- /// Emit an associative container (map).
- ///
- /// * `len` is the number of entries in the map.
- /// * `f` is a function that will call `emit_map_elt_key` and
- /// `emit_map_elt_val` for each entry in the map.
- ///
- /// # Examples
- ///
- /// ```
- /// use rustc_serialize::Encodable;
- /// use rustc_serialize::Encoder;
- ///
- /// struct SimpleMap<K,V> {
- /// entries: Vec<(K,V)>,
- /// }
- ///
- /// impl<K:Encodable,V:Encodable> Encodable for SimpleMap<K,V> {
- /// fn encode<S: Encoder>(&self, s: &mut S) -> Result<(), S::Error> {
- /// s.emit_map(self.entries.len(), |s| {
- /// for (i, e) in self.entries.iter().enumerate() {
- /// let (ref k, ref v) = *e;
- /// try!(s.emit_map_elt_key(i, |s| k.encode(s)));
- /// try!(s.emit_map_elt_val(i, |s| v.encode(s)));
- /// }
- /// Ok(())
- /// })
- /// }
- /// }
- /// ```
- fn emit_map<F>(&mut self, len: usize, f: F) -> Result<(), Self::Error>
- where F: FnOnce(&mut Self) -> Result<(), Self::Error>;
-
- /// Emit the key for an entry in a map.
- ///
- /// This should only be called from a function passed to `emit_map`.
- ///
- /// * `idx` is the (zero-based) index of the entry in the map
- /// * `f` is a function that will call the appropriate emit method to encode
- /// the key.
- ///
- /// Note that map entries must be emitted in order - starting with index `0`
- /// and finishing with index `len-1` - and for each entry, the key should be
- /// emitted followed immediately by the value.
- fn emit_map_elt_key<F>(&mut self, idx: usize, f: F) -> Result<(), Self::Error>
- where F: FnOnce(&mut Self) -> Result<(), Self::Error>;
-
- /// Emit the value for an entry in a map.
- ///
- /// This should only be called from a function passed to `emit_map`.
- ///
- /// * `idx` is the (zero-based) index of the entry in the map
- /// * `f` is a function that will call the appropriate emit method to encode
- /// the value.
- ///
- /// Note that map entries must be emitted in order - starting with index `0`
- /// and finishing with index `len-1` - and for each entry, the key should be
- /// emitted followed immediately by the value.
- fn emit_map_elt_val<F>(&mut self, idx: usize, f: F) -> Result<(), Self::Error>
- where F: FnOnce(&mut Self) -> Result<(), Self::Error>;
-}
-
-/// Trait for reading in an encoding for deserialization.
-///
-/// This trait provides methods to decode basic types and generic forms of
-/// collections. Implementations of `Decodable` use it to perform the actual
-/// decoding of a type.
-///
-/// Note that, as is typical with deserialization, the design of this API
-/// assumes you know in advance the form of the data you are decoding (ie: what
-/// type is encoded).
-///
-/// Decoders can expect to only have a single "root" method call made on this
-/// trait. Non-trivial types will call one of the collection-reading methods,
-/// passing a function that may call other methods on the trait, but once the
-/// collection-reading method has returned, decoding should be complete.
-pub trait Decoder {
- /// The error type for method results.
- type Error;
-
- // Primitive types:
- /// Read a nil value.
- fn read_nil(&mut self) -> Result<(), Self::Error>;
-
- /// Read a usize value.
- fn read_usize(&mut self) -> Result<usize, Self::Error>;
-
- /// Read a u64 value.
- fn read_u64(&mut self) -> Result<u64, Self::Error>;
-
- /// Read a u32 value.
- fn read_u32(&mut self) -> Result<u32, Self::Error>;
-
- /// Read a u16 value.
- fn read_u16(&mut self) -> Result<u16, Self::Error>;
-
- /// Read a u8 value.
- fn read_u8(&mut self) -> Result<u8, Self::Error>;
-
- /// Read a isize value.
- fn read_isize(&mut self) -> Result<isize, Self::Error>;
-
- /// Read a i64 value.
- fn read_i64(&mut self) -> Result<i64, Self::Error>;
-
- /// Read a i32 value.
- fn read_i32(&mut self) -> Result<i32, Self::Error>;
-
- /// Read a i16 value.
- fn read_i16(&mut self) -> Result<i16, Self::Error>;
-
- /// Read a i8 value.
- fn read_i8(&mut self) -> Result<i8, Self::Error>;
-
- /// Read a bool value.
- fn read_bool(&mut self) -> Result<bool, Self::Error>;
-
- /// Read a f64 value.
- fn read_f64(&mut self) -> Result<f64, Self::Error>;
-
- /// Read a f32 value.
- fn read_f32(&mut self) -> Result<f32, Self::Error>;
-
- /// Read a char value.
- fn read_char(&mut self) -> Result<char, Self::Error>;
-
- /// Read a string value.
- fn read_str(&mut self) -> Result<String, Self::Error>;
-
- // Compound types:
- /// Read an enumeration value.
- ///
- /// * `name` indicates the enumeration type name. It may be used to
- /// sanity-check the data being read.
- /// * `f` is a function that will call `read_enum_variant` (or
- /// `read_enum_struct_variant`) to read the actual value.
- fn read_enum<T, F>(&mut self, name: &str, f: F) -> Result<T, Self::Error>
- where F: FnOnce(&mut Self) -> Result<T, Self::Error>;
-
- /// Read an enumeration value.
- ///
- /// * `names` is a list of the enumeration variant names.
- /// * `f` is a function that will call `read_enum_variant_arg` or
- /// `read_enum_struct_variant_field` as appropriate to read the
- /// associated values. It will be passed the index into `names` for the
- /// variant that is encoded.
- fn read_enum_variant<T, F>(&mut self, names: &[&str], f: F)
- -> Result<T, Self::Error>
- where F: FnMut(&mut Self, usize) -> Result<T, Self::Error>;
-
- /// Read an unnamed data item for an enumeration variant.
- ///
- /// This should only be called from a function passed to `read_enum_variant`
- /// or `read_enum_struct_variant`, and only when the index provided to that
- /// function indicates that the variant has associated unnamed data. It
- /// should be called once for each associated data item.
- ///
- /// * `a_idx` is the (zero-based) index of the data item.
- /// * `f` is a function that will call the appropriate read method to deocde
- /// the data object.
- ///
- /// Note that variant data items must be read in order - starting with index
- /// `0` and finishing with index `len-1`. Implementations may use `a_idx`,
- /// the call order or both to select the correct data to decode.
- fn read_enum_variant_arg<T, F>(&mut self, a_idx: usize, f: F)
- -> Result<T, Self::Error>
- where F: FnOnce(&mut Self) -> Result<T, Self::Error>;
-
- /// Read an enumeration value.
- ///
- /// This is identical to `read_enum_variant`, and is only provided for
- /// symmetry with the `Encoder` API.
- fn read_enum_struct_variant<T, F>(&mut self, names: &[&str], f: F)
- -> Result<T, Self::Error>
- where F: FnMut(&mut Self, usize) -> Result<T, Self::Error>;
-
- /// Read a named data item for an enumeration variant.
- ///
- /// This should only be called from a function passed to `read_enum_variant`
- /// or `read_enum_struct_variant`, and only when the index provided to that
- /// function indicates that the variant has associated named data. It should
- /// be called once for each associated field.
- ///
- /// * `f_name` is the name of the field.
- /// * `f_idx` is the (zero-based) index of the data item.
- /// * `f` is a function that will call the appropriate read method to deocde
- /// the data object.
- ///
- /// Note that fields must be read in order - starting with index `0` and
- /// finishing with index `len-1`. Implementations may use `f_idx`, `f_name`,
- /// the call order or any combination to choose the correct data to decode,
- /// and may (but are not required to) return an error if these are
- /// inconsistent.
- fn read_enum_struct_variant_field<T, F>(&mut self,
- f_name: &str,
- f_idx: usize,
- f: F)
- -> Result<T, Self::Error>
- where F: FnOnce(&mut Self) -> Result<T, Self::Error>;
-
- /// Read an struct value.
- ///
- /// * `s_name` indicates the struct type name. It may be used to
- /// sanity-check the data being read.
- /// * `len` indicates the number of fields in the struct.
- /// * `f` is a function that will call `read_struct_field` for each field in
- /// the struct.
- fn read_struct<T, F>(&mut self, s_name: &str, len: usize, f: F)
- -> Result<T, Self::Error>
- where F: FnOnce(&mut Self) -> Result<T, Self::Error>;
-
- /// Read a field for a struct value.
- ///
- /// This should only be called from a function passed to `read_struct`. It
- /// should be called once for each associated field.
- ///
- /// * `f_name` is the name of the field.
- /// * `f_idx` is the (zero-based) index of the data item.
- /// * `f` is a function that will call the appropriate read method to deocde
- /// the data object.
- ///
- /// Note that fields must be read in order - starting with index `0` and
- /// finishing with index `len-1`. Implementations may use `f_idx`, `f_name`,
- /// the call order or any combination to choose the correct data to decode,
- /// and may (but are not required to) return an error if these are
- /// inconsistent.
- fn read_struct_field<T, F>(&mut self,
- f_name: &str,
- f_idx: usize,
- f: F)
- -> Result<T, Self::Error>
- where F: FnOnce(&mut Self) -> Result<T, Self::Error>;
-
- /// Read a tuple value.
- ///
- /// * `len` is the number of items in the tuple.
- /// * `f` is a function that will call `read_tuple_arg` for each item in the
- /// tuple.
- ///
- /// Note that external `Decodable` implementations should not normally need
- /// to use this method directly; it is meant for the use of this module's
- /// own implementation of `Decodable` for tuples.
- fn read_tuple<T, F>(&mut self, len: usize, f: F) -> Result<T, Self::Error>
- where F: FnOnce(&mut Self) -> Result<T, Self::Error>;
-
- /// Read a data item for a tuple.
- ///
- /// This should only be called from a function passed to `read_tuple`.
- ///
- /// * `a_idx` is the (zero-based) index of the data item.
- /// * `f` is a function that will call the appropriate read method to encode
- /// the data object.
- ///
- /// Note that tuple items must be read in order - starting with index `0`
- /// and finishing with index `len-1`.
- fn read_tuple_arg<T, F>(&mut self, a_idx: usize, f: F)
- -> Result<T, Self::Error>
- where F: FnOnce(&mut Self) -> Result<T, Self::Error>;
-
- /// Read a tuple struct value.
- ///
- /// * `s_name` is the name of the tuple struct.
- /// * `len` is the number of items in the tuple struct.
- /// * `f` is a function that calls `read_tuple_struct_arg` for each member.
- fn read_tuple_struct<T, F>(&mut self, s_name: &str, len: usize, f: F)
- -> Result<T, Self::Error>
- where F: FnOnce(&mut Self) -> Result<T, Self::Error>;
-
- /// Read a data item for a tuple struct.
- ///
- /// This should only be called from a function passed to
- /// `read_tuple_struct`.
- ///
- /// * `a_idx` is the (zero-based) index of the data item.
- /// * `f` is a function that will call the appropriate read method to encode
- /// the data object.
- ///
- /// Note that tuple struct items must be read in order - starting with index
- /// `0` and finishing with index `len-1`.
- fn read_tuple_struct_arg<T, F>(&mut self, a_idx: usize, f: F)
- -> Result<T, Self::Error>
- where F: FnOnce(&mut Self) -> Result<T, Self::Error>;
-
- // Specialized types:
- /// Read an optional value.
- ///
- /// `f` is a function that will will be passed be passed `false` if the
- /// value is unset, and `true` if it is set. If the function is passed
- /// `true`, it will call the appropriate read methods to read the associated
- /// data type.
- ///
- /// This method allows decoders to handle `Option<T>` values specially,
- /// rather than using the generic enum methods, because many encoding
- /// formats have a built-in "optional" concept.
- ///
- /// Note that external `Decodable` implementations should not normally need
- /// to use this method directly; it is meant for the use of this module's
- /// own implementation of `Decodable` for `Option<T>`.
- fn read_option<T, F>(&mut self, f: F) -> Result<T, Self::Error>
- where F: FnMut(&mut Self, bool) -> Result<T, Self::Error>;
-
- /// Read a sequence of values.
- ///
- /// This should be used for both array-like ordered sequences and set-like
- /// unordered ones.
- ///
- /// * `f` is a function that will be passed the length of the sequence, and
- /// will call `read_seq_elt` for each value in the sequence.
- fn read_seq<T, F>(&mut self, f: F) -> Result<T, Self::Error>
- where F: FnOnce(&mut Self, usize) -> Result<T, Self::Error>;
-
- /// Read an element in the sequence.
- ///
- /// This should only be called from a function passed to `read_seq`.
- ///
- /// * `idx` is the (zero-based) index of the value in the sequence.
- /// * `f` is a function that will call the appropriate read method to decode
- /// the data object.
- ///
- /// Note that sequence elements must be read in order - starting with index
- /// `0` and finishing with index `len-1`.
- fn read_seq_elt<T, F>(&mut self, idx: usize, f: F) -> Result<T, Self::Error>
- where F: FnOnce(&mut Self) -> Result<T, Self::Error>;
-
- /// Read an associative container (map).
- ///
- /// * `f` is a function that will be passed the number of entries in the
- /// map, and will call `read_map_elt_key` and `read_map_elt_val` to decode
- /// each entry.
- fn read_map<T, F>(&mut self, f: F) -> Result<T, Self::Error>
- where F: FnOnce(&mut Self, usize) -> Result<T, Self::Error>;
-
- /// Read the key for an entry in a map.
- ///
- /// This should only be called from a function passed to `read_map`.
- ///
- /// * `idx` is the (zero-based) index of the entry in the map
- /// * `f` is a function that will call the appropriate read method to decode
- /// the key.
- ///
- /// Note that map entries must be read in order - starting with index `0`
- /// and finishing with index `len-1` - and for each entry, the key should be
- /// read followed immediately by the value.
- fn read_map_elt_key<T, F>(&mut self, idx: usize, f: F)
- -> Result<T, Self::Error>
- where F: FnOnce(&mut Self) -> Result<T, Self::Error>;
-
- /// Read the value for an entry in a map.
- ///
- /// This should only be called from a function passed to `read_map`.
- ///
- /// * `idx` is the (zero-based) index of the entry in the map
- /// * `f` is a function that will call the appropriate read method to decode
- /// the value.
- ///
- /// Note that map entries must be read in order - starting with index `0`
- /// and finishing with index `len-1` - and for each entry, the key should be
- /// read followed immediately by the value.
- fn read_map_elt_val<T, F>(&mut self, idx: usize, f: F)
- -> Result<T, Self::Error>
- where F: FnOnce(&mut Self) -> Result<T, Self::Error>;
-
- // Failure
- /// Record a decoding error.
- ///
- /// This allows `Decodable` implementations to report an error using a
- /// `Decoder` implementation's error type when inconsistent data is read.
- /// For example, when reading a fixed-length array and the wrong length is
- /// given by `read_seq`.
- fn error(&mut self, err: &str) -> Self::Error;
-}
-
-/// Trait for serializing a type.
-///
-/// This can be implemented for custom data types to allow them to be encoded
-/// with `Encoder` implementations. Most of Rust's built-in or standard data
-/// types (like `i32` and `Vec<T>`) have `Encodable` implementations provided by
-/// this module.
-///
-/// Note that, in general, you should let the compiler implement this for you by
-/// using the `derive(RustcEncodable)` attribute.
-///
-/// # Examples
-///
-/// ```rust
-/// extern crate rustc_serialize;
-///
-/// #[derive(RustcEncodable)]
-/// struct Point {
-/// x: i32,
-/// y: i32,
-/// }
-/// # fn main() {}
-/// ```
-///
-/// This generates code equivalent to:
-///
-/// ```rust
-/// extern crate rustc_serialize;
-/// use rustc_serialize::Encodable;
-/// use rustc_serialize::Encoder;
-///
-/// struct Point {
-/// x: i32,
-/// y: i32,
-/// }
-///
-/// impl Encodable for Point {
-/// fn encode<S: Encoder>(&self, s: &mut S) -> Result<(), S::Error> {
-/// s.emit_struct("Point", 2, |s| {
-/// try!(s.emit_struct_field("x", 0, |s| {
-/// s.emit_i32(self.x)
-/// }));
-/// try!(s.emit_struct_field("y", 1, |s| {
-/// s.emit_i32(self.y)
-/// }));
-/// Ok(())
-/// })
-/// }
-/// }
-/// # fn main() {}
-/// ```
-pub trait Encodable {
- /// Serialize a value using an `Encoder`.
- fn encode<S: Encoder>(&self, s: &mut S) -> Result<(), S::Error>;
-}
-
-/// Trait for deserializing a type.
-///
-/// This can be implemented for custom data types to allow them to be decoded
-/// with `Decoder` implementations. Most of Rust's built-in or standard data
-/// types (like `i32` and `Vec<T>`) have `Decodable` implementations provided by
-/// this module.
-///
-/// Note that, in general, you should let the compiler implement this for you by
-/// using the `derive(RustcDecodable)` attribute.
-///
-/// # Examples
-///
-/// ```rust
-/// extern crate rustc_serialize;
-///
-/// #[derive(RustcDecodable)]
-/// struct Point {
-/// x: i32,
-/// y: i32,
-/// }
-/// # fn main() {}
-/// ```
-///
-/// This generates code equivalent to:
-///
-/// ```rust
-/// extern crate rustc_serialize;
-/// use rustc_serialize::Decodable;
-/// use rustc_serialize::Decoder;
-///
-/// struct Point {
-/// x: i32,
-/// y: i32,
-/// }
-///
-/// impl Decodable for Point {
-/// fn decode<D: Decoder>(d: &mut D) -> Result<Point, D::Error> {
-/// d.read_struct("Point", 2, |d| {
-/// let x = try!(d.read_struct_field("x", 0, |d| { d.read_i32() }));
-/// let y = try!(d.read_struct_field("y", 1, |d| { d.read_i32() }));
-/// Ok(Point{ x: x, y: y })
-/// })
-/// }
-/// }
-/// # fn main() {}
-/// ```
-pub trait Decodable: Sized {
- /// Deserialize a value using a `Decoder`.
- fn decode<D: Decoder>(d: &mut D) -> Result<Self, D::Error>;
-}
-
-impl Encodable for usize {
- fn encode<S: Encoder>(&self, s: &mut S) -> Result<(), S::Error> {
- s.emit_usize(*self)
- }
-}
-
-impl Decodable for usize {
- fn decode<D: Decoder>(d: &mut D) -> Result<usize, D::Error> {
- d.read_usize()
- }
-}
-
-impl Encodable for u8 {
- fn encode<S: Encoder>(&self, s: &mut S) -> Result<(), S::Error> {
- s.emit_u8(*self)
- }
-}
-
-impl Decodable for u8 {
- fn decode<D: Decoder>(d: &mut D) -> Result<u8, D::Error> {
- d.read_u8()
- }
-}
-
-impl Encodable for u16 {
- fn encode<S: Encoder>(&self, s: &mut S) -> Result<(), S::Error> {
- s.emit_u16(*self)
- }
-}
-
-impl Decodable for u16 {
- fn decode<D: Decoder>(d: &mut D) -> Result<u16, D::Error> {
- d.read_u16()
- }
-}
-
-impl Encodable for u32 {
- fn encode<S: Encoder>(&self, s: &mut S) -> Result<(), S::Error> {
- s.emit_u32(*self)
- }
-}
-
-impl Decodable for u32 {
- fn decode<D: Decoder>(d: &mut D) -> Result<u32, D::Error> {
- d.read_u32()
- }
-}
-
-impl Encodable for u64 {
- fn encode<S: Encoder>(&self, s: &mut S) -> Result<(), S::Error> {
- s.emit_u64(*self)
- }
-}
-
-impl Decodable for u64 {
- fn decode<D: Decoder>(d: &mut D) -> Result<u64, D::Error> {
- d.read_u64()
- }
-}
-
-impl Encodable for isize {
- fn encode<S: Encoder>(&self, s: &mut S) -> Result<(), S::Error> {
- s.emit_isize(*self)
- }
-}
-
-impl Decodable for isize {
- fn decode<D: Decoder>(d: &mut D) -> Result<isize, D::Error> {
- d.read_isize()
- }
-}
-
-impl Encodable for i8 {
- fn encode<S: Encoder>(&self, s: &mut S) -> Result<(), S::Error> {
- s.emit_i8(*self)
- }
-}
-
-impl Decodable for i8 {
- fn decode<D: Decoder>(d: &mut D) -> Result<i8, D::Error> {
- d.read_i8()
- }
-}
-
-impl Encodable for i16 {
- fn encode<S: Encoder>(&self, s: &mut S) -> Result<(), S::Error> {
- s.emit_i16(*self)
- }
-}
-
-impl Decodable for i16 {
- fn decode<D: Decoder>(d: &mut D) -> Result<i16, D::Error> {
- d.read_i16()
- }
-}
-
-impl Encodable for i32 {
- fn encode<S: Encoder>(&self, s: &mut S) -> Result<(), S::Error> {
- s.emit_i32(*self)
- }
-}
-
-impl Decodable for i32 {
- fn decode<D: Decoder>(d: &mut D) -> Result<i32, D::Error> {
- d.read_i32()
- }
-}
-
-impl Encodable for i64 {
- fn encode<S: Encoder>(&self, s: &mut S) -> Result<(), S::Error> {
- s.emit_i64(*self)
- }
-}
-
-impl Decodable for i64 {
- fn decode<D: Decoder>(d: &mut D) -> Result<i64, D::Error> {
- d.read_i64()
- }
-}
-
-impl Encodable for str {
- fn encode<S: Encoder>(&self, s: &mut S) -> Result<(), S::Error> {
- s.emit_str(self)
- }
-}
-
-impl Encodable for String {
- fn encode<S: Encoder>(&self, s: &mut S) -> Result<(), S::Error> {
- s.emit_str(self)
- }
-}
-
-impl Decodable for String {
- fn decode<D: Decoder>(d: &mut D) -> Result<String, D::Error> {
- d.read_str()
- }
-}
-
-impl Encodable for f32 {
- fn encode<S: Encoder>(&self, s: &mut S) -> Result<(), S::Error> {
- s.emit_f32(*self)
- }
-}
-
-impl Decodable for f32 {
- fn decode<D: Decoder>(d: &mut D) -> Result<f32, D::Error> {
- d.read_f32()
- }
-}
-
-impl Encodable for f64 {
- fn encode<S: Encoder>(&self, s: &mut S) -> Result<(), S::Error> {
- s.emit_f64(*self)
- }
-}
-
-impl Decodable for f64 {
- fn decode<D: Decoder>(d: &mut D) -> Result<f64, D::Error> {
- d.read_f64()
- }
-}
-
-impl Encodable for bool {
- fn encode<S: Encoder>(&self, s: &mut S) -> Result<(), S::Error> {
- s.emit_bool(*self)
- }
-}
-
-impl Decodable for bool {
- fn decode<D: Decoder>(d: &mut D) -> Result<bool, D::Error> {
- d.read_bool()
- }
-}
-
-impl Encodable for char {
- fn encode<S: Encoder>(&self, s: &mut S) -> Result<(), S::Error> {
- s.emit_char(*self)
- }
-}
-
-impl Decodable for char {
- fn decode<D: Decoder>(d: &mut D) -> Result<char, D::Error> {
- d.read_char()
- }
-}
-
-impl Encodable for () {
- fn encode<S: Encoder>(&self, s: &mut S) -> Result<(), S::Error> {
- s.emit_nil()
- }
-}
-
-impl Decodable for () {
- fn decode<D: Decoder>(d: &mut D) -> Result<(), D::Error> {
- d.read_nil()
- }
-}
-
-impl<'a, T: ?Sized + Encodable> Encodable for &'a T {
- fn encode<S: Encoder>(&self, s: &mut S) -> Result<(), S::Error> {
- (**self).encode(s)
- }
-}
-
-impl<T: ?Sized + Encodable> Encodable for Box<T> {
- fn encode<S: Encoder>(&self, s: &mut S) -> Result<(), S::Error> {
- (**self).encode(s)
- }
-}
-
-impl< T: Decodable> Decodable for Box<T> {
- fn decode<D: Decoder>(d: &mut D) -> Result<Box<T>, D::Error> {
- Ok(Box::new(try!(Decodable::decode(d))))
- }
-}
-
-impl< T: Decodable> Decodable for Box<[T]> {
- fn decode<D: Decoder>(d: &mut D) -> Result<Box<[T]>, D::Error> {
- let v: Vec<T> = try!(Decodable::decode(d));
- Ok(v.into_boxed_slice())
- }
-}
-
-impl<T:Encodable> Encodable for Rc<T> {
- #[inline]
- fn encode<S: Encoder>(&self, s: &mut S) -> Result<(), S::Error> {
- (**self).encode(s)
- }
-}
-
-impl<T:Decodable> Decodable for Rc<T> {
- #[inline]
- fn decode<D: Decoder>(d: &mut D) -> Result<Rc<T>, D::Error> {
- Ok(Rc::new(try!(Decodable::decode(d))))
- }
-}
-
-impl<'a, T:Encodable + ToOwned + ?Sized> Encodable for Cow<'a, T> {
- #[inline]
- fn encode<S: Encoder>(&self, s: &mut S) -> Result<(), S::Error> {
- (**self).encode(s)
- }
-}
-
-impl<'a, T: ?Sized> Decodable for Cow<'a, T>
- where T: ToOwned, T::Owned: Decodable
-{
- #[inline]
- fn decode<D: Decoder>(d: &mut D) -> Result<Cow<'static, T>, D::Error> {
- Ok(Cow::Owned(try!(Decodable::decode(d))))
- }
-}
-
-impl<T:Encodable> Encodable for [T] {
- fn encode<S: Encoder>(&self, s: &mut S) -> Result<(), S::Error> {
- s.emit_seq(self.len(), |s| {
- for (i, e) in self.iter().enumerate() {
- try!(s.emit_seq_elt(i, |s| e.encode(s)))
- }
- Ok(())
- })
- }
-}
-
-impl<T:Encodable> Encodable for Vec<T> {
- fn encode<S: Encoder>(&self, s: &mut S) -> Result<(), S::Error> {
- s.emit_seq(self.len(), |s| {
- for (i, e) in self.iter().enumerate() {
- try!(s.emit_seq_elt(i, |s| e.encode(s)))
- }
- Ok(())
- })
- }
-}
-
-impl<T:Decodable> Decodable for Vec<T> {
- fn decode<D: Decoder>(d: &mut D) -> Result<Vec<T>, D::Error> {
- d.read_seq(|d, len| {
- let mut v = Vec::with_capacity(cap_capacity::<T>(len));
- for i in 0..len {
- v.push(try!(d.read_seq_elt(i, |d| Decodable::decode(d))));
- }
- Ok(v)
- })
- }
-}
-
-impl<T:Encodable> Encodable for Option<T> {
- fn encode<S: Encoder>(&self, s: &mut S) -> Result<(), S::Error> {
- s.emit_option(|s| {
- match *self {
- None => s.emit_option_none(),
- Some(ref v) => s.emit_option_some(|s| v.encode(s)),
- }
- })
- }
-}
-
-impl<T:Decodable> Decodable for Option<T> {
- fn decode<D: Decoder>(d: &mut D) -> Result<Option<T>, D::Error> {
- d.read_option(|d, b| {
- if b {
- Ok(Some(try!(Decodable::decode(d))))
- } else {
- Ok(None)
- }
- })
- }
-}
-
-impl<T:Encodable, E:Encodable> Encodable for Result<T, E> {
- fn encode<S: Encoder>(&self, s: &mut S) -> Result<(), S::Error> {
- s.emit_enum("Result", |s| {
- match *self {
- Ok(ref v) => {
- s.emit_enum_variant("Ok", 0, 1, |s| {
- try!(s.emit_enum_variant_arg(0, |s| {
- v.encode(s)
- }));
- Ok(())
- })
- }
- Err(ref v) => {
- s.emit_enum_variant("Err", 1, 1, |s| {
- try!(s.emit_enum_variant_arg(0, |s| {
- v.encode(s)
- }));
- Ok(())
- })
- }
- }
- })
- }
-}
-
-impl<T: Decodable, E: Decodable> Decodable for Result<T, E> {
- fn decode<D: Decoder>(d: &mut D) -> Result<Result<T, E>, D::Error> {
- d.read_enum("Result", |d| {
- d.read_enum_variant(&["Ok", "Err"], |d, idx| {
- match idx {
- 0 => {
- d.read_enum_variant_arg(0, |d| {
- T::decode(d)
- }).map(|v| Ok(v))
- }
- 1 => {
- d.read_enum_variant_arg(0, |d| {
- E::decode(d)
- }).map(|v| Err(v))
- }
- _ => panic!("Internal error"),
- }
- })
- })
- }
-}
-
-impl<T> Encodable for PhantomData<T> {
- fn encode<S: Encoder>(&self, s: &mut S) -> Result<(), S::Error> {
- s.emit_nil()
- }
-}
-
-impl<T> Decodable for PhantomData<T> {
- fn decode<D: Decoder>(_d: &mut D) -> Result<PhantomData<T>, D::Error> {
- Ok(PhantomData)
- }
-}
-
-macro_rules! peel {
- ($name:ident, $($other:ident,)*) => (tuple! { $($other,)* })
-}
-
-/// Evaluates to the number of identifiers passed to it, for example:
-/// `count_idents!(a, b, c) == 3
-macro_rules! count_idents {
- () => { 0 };
- ($_i:ident, $($rest:ident,)*) => { 1 + count_idents!($($rest,)*) }
-}
-
-macro_rules! tuple {
- () => ();
- ( $($name:ident,)+ ) => (
- impl<$($name:Decodable),*> Decodable for ($($name,)*) {
- fn decode<D: Decoder>(d: &mut D) -> Result<($($name,)*), D::Error> {
- let len: usize = count_idents!($($name,)*);
- d.read_tuple(len, |d| {
- let mut i = 0;
- let ret = ($(try!(d.read_tuple_arg({ i+=1; i-1 },
- |d| -> Result<$name,D::Error> {
- Decodable::decode(d)
- })),)*);
- return Ok(ret);
- })
- }
- }
- impl<$($name:Encodable),*> Encodable for ($($name,)*) {
- #[allow(non_snake_case)]
- fn encode<S: Encoder>(&self, s: &mut S) -> Result<(), S::Error> {
- let ($(ref $name,)*) = *self;
- let mut n = 0;
- $(let $name = $name; n += 1;)*
- s.emit_tuple(n, |s| {
- let mut i = 0;
- $(try!(s.emit_tuple_arg({ i+=1; i-1 }, |s| $name.encode(s)));)*
- Ok(())
- })
- }
- }
- peel! { $($name,)* }
- )
-}
-
-tuple! { T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, }
-
-macro_rules! array {
- () => ();
- ($len:expr, $($idx:expr,)*) => {
- impl<T:Decodable> Decodable for [T; $len] {
- fn decode<D: Decoder>(d: &mut D) -> Result<[T; $len], D::Error> {
- d.read_seq(|d, len| {
- if len != $len {
- return Err(d.error("wrong array length"));
- }
- Ok([$(
- try!(d.read_seq_elt($len - $idx - 1,
- |d| Decodable::decode(d)))
- ),*])
- })
- }
- }
-
- impl<T:Encodable> Encodable for [T; $len] {
- fn encode<S: Encoder>(&self, s: &mut S) -> Result<(), S::Error> {
- s.emit_seq($len, |s| {
- for i in 0..$len {
- try!(s.emit_seq_elt(i, |s| self[i].encode(s)));
- }
- Ok(())
- })
- }
- }
- array! { $($idx,)* }
- }
-}
-
-array! {
- 32, 31, 30, 29, 28, 27, 26, 25, 24, 23, 22, 21, 20, 19, 18, 17, 16,
- 15, 14, 13, 12, 11, 10, 9, 8, 7, 6, 5, 4, 3, 2, 1, 0,
-}
-
-impl Encodable for path::Path {
- #[cfg(target_os = "redox")]
- fn encode<S: Encoder>(&self, e: &mut S) -> Result<(), S::Error> {
- self.as_os_str().to_str().unwrap().encode(e)
- }
- #[cfg(unix)]
- fn encode<S: Encoder>(&self, e: &mut S) -> Result<(), S::Error> {
- use std::os::unix::prelude::*;
- self.as_os_str().as_bytes().encode(e)
- }
- #[cfg(windows)]
- fn encode<S: Encoder>(&self, e: &mut S) -> Result<(), S::Error> {
- use std::os::windows::prelude::*;
- let v = self.as_os_str().encode_wide().collect::<Vec<_>>();
- v.encode(e)
- }
-}
-
-impl Encodable for path::PathBuf {
- fn encode<S: Encoder>(&self, e: &mut S) -> Result<(), S::Error> {
- (**self).encode(e)
- }
-}
-
-impl Decodable for path::PathBuf {
- #[cfg(target_os = "redox")]
- fn decode<D: Decoder>(d: &mut D) -> Result<path::PathBuf, D::Error> {
- let string: String = try!(Decodable::decode(d));
- let s: OsString = OsString::from(string);
- let mut p = path::PathBuf::new();
- p.push(s);
- Ok(p)
- }
- #[cfg(unix)]
- fn decode<D: Decoder>(d: &mut D) -> Result<path::PathBuf, D::Error> {
- use std::os::unix::prelude::*;
- let bytes: Vec<u8> = try!(Decodable::decode(d));
- let s: OsString = OsStringExt::from_vec(bytes);
- let mut p = path::PathBuf::new();
- p.push(s);
- Ok(p)
- }
- #[cfg(windows)]
- fn decode<D: Decoder>(d: &mut D) -> Result<path::PathBuf, D::Error> {
- use std::os::windows::prelude::*;
- let bytes: Vec<u16> = try!(Decodable::decode(d));
- let s: OsString = OsStringExt::from_wide(&bytes);
- let mut p = path::PathBuf::new();
- p.push(s);
- Ok(p)
- }
-}
-
-impl<T: Encodable + Copy> Encodable for Cell<T> {
- fn encode<S: Encoder>(&self, s: &mut S) -> Result<(), S::Error> {
- self.get().encode(s)
- }
-}
-
-impl<T: Decodable + Copy> Decodable for Cell<T> {
- fn decode<D: Decoder>(d: &mut D) -> Result<Cell<T>, D::Error> {
- Ok(Cell::new(try!(Decodable::decode(d))))
- }
-}
-
-// FIXME: #15036
-// Should use `try_borrow`, returning a
-// `encoder.error("attempting to Encode borrowed RefCell")`
-// from `encode` when `try_borrow` returns `None`.
-
-impl<T: Encodable> Encodable for RefCell<T> {
- fn encode<S: Encoder>(&self, s: &mut S) -> Result<(), S::Error> {
- self.borrow().encode(s)
- }
-}
-
-impl<T: Decodable> Decodable for RefCell<T> {
- fn decode<D: Decoder>(d: &mut D) -> Result<RefCell<T>, D::Error> {
- Ok(RefCell::new(try!(Decodable::decode(d))))
- }
-}
-
-impl<T:Encodable> Encodable for Arc<T> {
- fn encode<S: Encoder>(&self, s: &mut S) -> Result<(), S::Error> {
- (**self).encode(s)
- }
-}
-
-impl<T:Decodable+Send+Sync> Decodable for Arc<T> {
- fn decode<D: Decoder>(d: &mut D) -> Result<Arc<T>, D::Error> {
- Ok(Arc::new(try!(Decodable::decode(d))))
- }
-}
-
-// ___________________________________________________________________________
-// Helper routines
-
-/// Trait with helper functions for implementing `Encodable`.
-///
-/// This trait is implemented for everything that implements `Encoder`.
-/// `Encodable` implementations can make use of it to make their implementations
-/// easier.
-pub trait EncoderHelpers: Encoder {
- /// Emit a vector as a sequence.
- ///
- /// Storing sequences as vectors is a common pattern. This method makes
- /// encoding such sequences easier by wrapping the calls to
- /// `Encoder::emit_seq` and `Encoder::emit_seq_elt`.
- ///
- /// # Examples
- ///
- /// ```
- /// use rustc_serialize::Encodable;
- /// use rustc_serialize::Encoder;
- /// use rustc_serialize::EncoderHelpers;
- ///
- /// struct NumberSequence {
- /// elements: Vec<i32>,
- /// }
- ///
- /// impl Encodable for NumberSequence {
- /// fn encode<S: Encoder>(&self, s: &mut S) -> Result<(), S::Error> {
- /// s.emit_struct("NumberSequence", 1, |s| {
- /// s.emit_struct_field("elements", 0, |s| {
- /// s.emit_from_vec(&self.elements, |s,e| {
- /// s.emit_i32(*e)
- /// })
- /// })
- /// })
- /// }
- /// }
- /// ```
- fn emit_from_vec<T, F>(&mut self, v: &[T], f: F)
- -> Result<(), <Self as Encoder>::Error>
- where F: FnMut(&mut Self, &T) -> Result<(), <Self as Encoder>::Error>;
-}
-
-impl<S:Encoder> EncoderHelpers for S {
- fn emit_from_vec<T, F>(&mut self, v: &[T], mut f: F) -> Result<(), S::Error> where
- F: FnMut(&mut S, &T) -> Result<(), S::Error>,
- {
- self.emit_seq(v.len(), |this| {
- for (i, e) in v.iter().enumerate() {
- try!(this.emit_seq_elt(i, |this| {
- f(this, e)
- }));
- }
- Ok(())
- })
- }
-}
-
-/// Trait with helper functions for implementing `Decodable`.
-///
-/// This trait is implemented for everything that implements `Decoder`.
-/// `Decodable` implementations can make use of it to make their implementations
-/// easier.
-pub trait DecoderHelpers: Decoder {
- /// Read a sequence into a vector.
- ///
- /// Storing sequences as vectors is a common pattern. This method makes
- /// deserializing such sequences easier by wrapping the calls to
- /// `Decoder::read_seq` and `Decoder::read_seq_elt`.
- ///
- /// # Examples
- ///
- /// ```
- /// use rustc_serialize::Decodable;
- /// use rustc_serialize::Decoder;
- /// use rustc_serialize::DecoderHelpers;
- ///
- /// struct NumberSequence {
- /// elements: Vec<i32>,
- /// }
- ///
- /// impl Decodable for NumberSequence {
- /// fn decode<D: Decoder>(d: &mut D) -> Result<NumberSequence, D::Error> {
- /// d.read_struct("NumberSequence", 2, |d| {
- /// Ok(NumberSequence{
- /// elements: try!(d.read_struct_field("elements", 0, |d| {
- /// d.read_to_vec(|d| { d.read_i32() })
- /// }))
- /// })
- /// })
- /// }
- /// }
- /// ```
- fn read_to_vec<T, F>(&mut self, f: F)
- -> Result<Vec<T>, <Self as Decoder>::Error> where
- F: FnMut(&mut Self) -> Result<T, <Self as Decoder>::Error>;
-}
-
-impl<D: Decoder> DecoderHelpers for D {
- fn read_to_vec<T, F>(&mut self, mut f: F) -> Result<Vec<T>, D::Error> where F:
- FnMut(&mut D) -> Result<T, D::Error>,
- {
- self.read_seq(|this, len| {
- let mut v = Vec::with_capacity(cap_capacity::<T>(len));
- for i in 0..len {
- v.push(try!(this.read_seq_elt(i, |this| f(this))));
- }
- Ok(v)
- })
- }
-}
-
-#[test]
-#[allow(unused_variables)]
-fn capacity_rules() {
- use std::usize::MAX;
- use std::collections::{HashMap, HashSet};
-
- struct MyDecoder;
- impl Decoder for MyDecoder {
- type Error = ();
-
- // Primitive types:
- fn read_nil(&mut self) -> Result<(), Self::Error> { Err(()) }
- fn read_usize(&mut self) -> Result<usize, Self::Error> { Err(()) }
- fn read_u64(&mut self) -> Result<u64, Self::Error> { Err(()) }
- fn read_u32(&mut self) -> Result<u32, Self::Error> { Err(()) }
- fn read_u16(&mut self) -> Result<u16, Self::Error> { Err(()) }
- fn read_u8(&mut self) -> Result<u8, Self::Error> { Err(()) }
- fn read_isize(&mut self) -> Result<isize, Self::Error> { Err(()) }
- fn read_i64(&mut self) -> Result<i64, Self::Error> { Err(()) }
- fn read_i32(&mut self) -> Result<i32, Self::Error> { Err(()) }
- fn read_i16(&mut self) -> Result<i16, Self::Error> { Err(()) }
- fn read_i8(&mut self) -> Result<i8, Self::Error> { Err(()) }
- fn read_bool(&mut self) -> Result<bool, Self::Error> { Err(()) }
- fn read_f64(&mut self) -> Result<f64, Self::Error> { Err(()) }
- fn read_f32(&mut self) -> Result<f32, Self::Error> { Err(()) }
- fn read_char(&mut self) -> Result<char, Self::Error> { Err(()) }
- fn read_str(&mut self) -> Result<String, Self::Error> { Err(()) }
-
- // Compound types:
- fn read_enum<T, F>(&mut self, name: &str, f: F) -> Result<T, Self::Error>
- where F: FnOnce(&mut Self) -> Result<T, Self::Error> { Err(()) }
-
- fn read_enum_variant<T, F>(&mut self, names: &[&str], f: F)
- -> Result<T, Self::Error>
- where F: FnMut(&mut Self, usize) -> Result<T, Self::Error> { Err(()) }
- fn read_enum_variant_arg<T, F>(&mut self, a_idx: usize, f: F)
- -> Result<T, Self::Error>
- where F: FnOnce(&mut Self) -> Result<T, Self::Error> { Err(()) }
-
- fn read_enum_struct_variant<T, F>(&mut self, names: &[&str], f: F)
- -> Result<T, Self::Error>
- where F: FnMut(&mut Self, usize) -> Result<T, Self::Error> { Err(()) }
- fn read_enum_struct_variant_field<T, F>(&mut self,
- f_name: &str,
- f_idx: usize,
- f: F)
- -> Result<T, Self::Error>
- where F: FnOnce(&mut Self) -> Result<T, Self::Error> { Err(()) }
-
- fn read_struct<T, F>(&mut self, s_name: &str, len: usize, f: F)
- -> Result<T, Self::Error>
- where F: FnOnce(&mut Self) -> Result<T, Self::Error> { Err(()) }
- fn read_struct_field<T, F>(&mut self,
- f_name: &str,
- f_idx: usize,
- f: F)
- -> Result<T, Self::Error>
- where F: FnOnce(&mut Self) -> Result<T, Self::Error> { Err(()) }
-
- fn read_tuple<T, F>(&mut self, len: usize, f: F) -> Result<T, Self::Error>
- where F: FnOnce(&mut Self) -> Result<T, Self::Error> { Err(()) }
- fn read_tuple_arg<T, F>(&mut self, a_idx: usize, f: F)
- -> Result<T, Self::Error>
- where F: FnOnce(&mut Self) -> Result<T, Self::Error> { Err(()) }
-
- fn read_tuple_struct<T, F>(&mut self, s_name: &str, len: usize, f: F)
- -> Result<T, Self::Error>
- where F: FnOnce(&mut Self) -> Result<T, Self::Error> { Err(()) }
- fn read_tuple_struct_arg<T, F>(&mut self, a_idx: usize, f: F)
- -> Result<T, Self::Error>
- where F: FnOnce(&mut Self) -> Result<T, Self::Error> { Err(()) }
-
- // Specialized types:
- fn read_option<T, F>(&mut self, f: F) -> Result<T, Self::Error>
- where F: FnMut(&mut Self, bool) -> Result<T, Self::Error> { Err(()) }
-
- fn read_seq<T, F>(&mut self, f: F) -> Result<T, Self::Error>
- where F: FnOnce(&mut Self, usize) -> Result<T, Self::Error> {
- f(self, MAX)
- }
- fn read_seq_elt<T, F>(&mut self, idx: usize, f: F) -> Result<T, Self::Error>
- where F: FnOnce(&mut Self) -> Result<T, Self::Error> { Err(()) }
-
- fn read_map<T, F>(&mut self, f: F) -> Result<T, Self::Error>
- where F: FnOnce(&mut Self, usize) -> Result<T, Self::Error> {
- f(self, MAX)
- }
- fn read_map_elt_key<T, F>(&mut self, idx: usize, f: F)
- -> Result<T, Self::Error>
- where F: FnOnce(&mut Self) -> Result<T, Self::Error> { Err(()) }
- fn read_map_elt_val<T, F>(&mut self, idx: usize, f: F)
- -> Result<T, Self::Error>
- where F: FnOnce(&mut Self) -> Result<T, Self::Error> { Err(()) }
-
- // Failure
- fn error(&mut self, err: &str) -> Self::Error { () }
- }
-
- let mut dummy = MyDecoder;
- let vec_result: Result<Vec<u8>, ()> = Decodable::decode(&mut dummy);
- assert!(vec_result.is_err());
-
- let map_result: Result<HashMap<u8, u8>, ()> = Decodable::decode(&mut dummy);
- assert!(map_result.is_err());
-
- let set_result: Result<HashSet<u8>, ()> = Decodable::decode(&mut dummy);
- assert!(set_result.is_err());
-}
new file mode 100644
--- /dev/null
+++ b/third_party/rust/serde_json/.cargo-checksum.json
@@ -0,0 +1,1 @@
+{"files":{"Cargo.toml":"69ba75f76da91885bade39b85c2dd7595cda20cb406b571e17f42ab496139c48","LICENSE-APACHE":"a60eea817514531668d7e00765731449fe14d059d3249e0bc93b36de45f759f2","LICENSE-MIT":"6485b8ed310d3f0340bf1ad1f47645069ce4069dcc6bb46c7d5c6faf41de1fdb","README.md":"c4d8690cd2aa2db200ecdf2f2113fc8e3f4ccc88f3dc96da22189f45136932d0","src/de.rs":"42d7aa8cf85baa1b3851180e32af883c11ca2889df6f4eb306670f360af46d3e","src/error.rs":"8ac6d4c861891c133b3359b2a14fccb8a6d463a4b2c13f0d658884c1972186ce","src/iter.rs":"b5c77c5482e45bed1e63bd36a0f991a08f732811546a163228be48303e7f1b4d","src/lib.rs":"0da5b1e1e014de3c00a3396295d288a9911ade5a16e7810cf02be8435707e7a2","src/macros.rs":"16eaee6a82152d1d26c5a62a4435b7c9c47e67313da917e78501cad565ea1e5f","src/map.rs":"44bcb1d95be564da0ff087fa272e12311b7a7dcf05401909f8651ce9b46ef798","src/number.rs":"bf72dc7a93cfa5225309fac9ba5a01ba34ca2177e7c5037760b9aed983c82c5d","src/read.rs":"832bc530dd35ee24df59c1cf648cfbbffc4c2e72e86104b0e186582ae0de545a","src/ser.rs":"1444b537ae69171261be4835a9891574570152518312720786b9f1dd9fb423f4","src/value/de.rs":"b25d9192f179f84c0ecb2226216ff663c39ebdde524179f7118718f3202243cf","src/value/from.rs":"13a6c7b0b327f23c2fd899c8390e8ddfd8907bfcfc362e80834b9ae7ddb698e9","src/value/index.rs":"b9a8cc6f37e2a079a5e4ab1bf25fa9ff076c514870e0756a0c88af3ffa0f51a8","src/value/mod.rs":"8d0ac56fcd12aee1c645afdfe0df62b10527cab21d16284fe9f0bd6768457002","src/value/partial_eq.rs":"5924e245408afc8075e2bb9dda479c938c6c8cdd3c18b54697aa2b33fffda57b","src/value/ser.rs":"4bbc3ad0f646464f1e9b9a2c2e48df799d02ef658eacadc35971b897cfe7cd02"},"package":"84b8035cabe9b35878adec8ac5fe03d5f6bc97ff6edd7ccb96b44c1276ba390e"}
\ No newline at end of file
new file mode 100644
--- /dev/null
+++ b/third_party/rust/serde_json/Cargo.toml
@@ -0,0 +1,54 @@
+# THIS FILE IS AUTOMATICALLY GENERATED BY CARGO
+#
+# When uploading crates to the registry Cargo will automatically
+# "normalize" Cargo.toml files for maximal compatibility
+# with all versions of Cargo and also rewrite `path` dependencies
+# to registry (e.g. crates.io) dependencies
+#
+# If you believe there's an error in this file please file an
+# issue against the rust-lang/cargo repository. If you're
+# editing this file be aware that the upstream Cargo.toml
+# will likely look very different (and much more reasonable)
+
+[package]
+name = "serde_json"
+version = "1.0.22"
+authors = ["Erick Tryzelaar <erick.tryzelaar@gmail.com>", "David Tolnay <dtolnay@gmail.com>"]
+include = ["Cargo.toml", "src/**/*.rs", "README.md", "LICENSE-APACHE", "LICENSE-MIT"]
+description = "A JSON serialization file format"
+documentation = "http://docs.serde.rs/serde_json/"
+readme = "README.md"
+keywords = ["json", "serde", "serialization"]
+categories = ["encoding"]
+license = "MIT/Apache-2.0"
+repository = "https://github.com/serde-rs/json"
+[dependencies.dtoa]
+version = "0.4"
+
+[dependencies.indexmap]
+version = "1.0"
+optional = true
+
+[dependencies.itoa]
+version = "0.4"
+
+[dependencies.serde]
+version = "1.0.60"
+[dev-dependencies.compiletest_rs]
+version = "0.3"
+
+[dev-dependencies.serde_bytes]
+version = "0.10"
+
+[dev-dependencies.serde_derive]
+version = "1.0"
+
+[features]
+arbitrary_precision = []
+default = []
+preserve_order = ["indexmap"]
+[badges.appveyor]
+repository = "serde-rs/json"
+
+[badges.travis-ci]
+repository = "serde-rs/json"
rename from third_party/rust/rustc-serialize/LICENSE-APACHE
rename to third_party/rust/serde_json/LICENSE-APACHE
rename from third_party/rust/rustc-serialize/LICENSE-MIT
rename to third_party/rust/serde_json/LICENSE-MIT
new file mode 100644
--- /dev/null
+++ b/third_party/rust/serde_json/README.md
@@ -0,0 +1,365 @@
+# Serde JSON   [![Build Status]][travis] [![Latest Version]][crates.io] [![Rustc Version 1.15+]][rustc]
+
+[Build Status]: https://api.travis-ci.org/serde-rs/json.svg?branch=master
+[travis]: https://travis-ci.org/serde-rs/json
+[Latest Version]: https://img.shields.io/crates/v/serde_json.svg
+[crates.io]: https://crates.io/crates/serde\_json
+[Rustc Version 1.15+]: https://img.shields.io/badge/rustc-1.15+-lightgray.svg
+[rustc]: https://blog.rust-lang.org/2017/02/02/Rust-1.15.html
+
+**Serde is a framework for *ser*ializing and *de*serializing Rust data structures efficiently and generically.**
+
+---
+
+```toml
+[dependencies]
+serde_json = "1.0"
+```
+
+You may be looking for:
+
+- [JSON API documentation](https://docs.serde.rs/serde_json/)
+- [Serde API documentation](https://docs.serde.rs/serde/)
+- [Detailed documentation about Serde](https://serde.rs/)
+- [Setting up `#[derive(Serialize, Deserialize)]`](https://serde.rs/codegen.html)
+- [Release notes](https://github.com/serde-rs/json/releases)
+
+JSON is a ubiquitous open-standard format that uses human-readable text to
+transmit data objects consisting of key-value pairs.
+
+```json,ignore
+{
+ "name": "John Doe",
+ "age": 43,
+ "address": {
+ "street": "10 Downing Street",
+ "city": "London"
+ },
+ "phones": [
+ "+44 1234567",
+ "+44 2345678"
+ ]
+}
+```
+
+There are three common ways that you might find yourself needing to work
+with JSON data in Rust.
+
+ - **As text data.** An unprocessed string of JSON data that you receive on
+ an HTTP endpoint, read from a file, or prepare to send to a remote
+ server.
+ - **As an untyped or loosely typed representation.** Maybe you want to
+ check that some JSON data is valid before passing it on, but without
+ knowing the structure of what it contains. Or you want to do very basic
+ manipulations like insert a key in a particular spot.
+ - **As a strongly typed Rust data structure.** When you expect all or most
+ of your data to conform to a particular structure and want to get real
+ work done without JSON's loosey-goosey nature tripping you up.
+
+Serde JSON provides efficient, flexible, safe ways of converting data
+between each of these representations.
+
+## Operating on untyped JSON values
+
+Any valid JSON data can be manipulated in the following recursive enum
+representation. This data structure is [`serde_json::Value`][value].
+
+```rust,ignore
+enum Value {
+ Null,
+ Bool(bool),
+ Number(Number),
+ String(String),
+ Array(Vec<Value>),
+ Object(Map<String, Value>),
+}
+```
+
+A string of JSON data can be parsed into a `serde_json::Value` by the
+[`serde_json::from_str`][from_str] function. There is also
+[`from_slice`][from_slice] for parsing from a byte slice &[u8] and
+[`from_reader`][from_reader] for parsing from any `io::Read` like a File or
+a TCP stream.
+
+<a href="http://play.integer32.com/?gist=a266662bc71712e080efbf25ce30f306" target="_blank">
+<img align="right" width="50" src="https://raw.githubusercontent.com/serde-rs/serde-rs.github.io/master/img/run.png">
+</a>
+
+```rust
+extern crate serde_json;
+
+use serde_json::{Value, Error};
+
+fn untyped_example() -> Result<(), Error> {
+ // Some JSON input data as a &str. Maybe this comes from the user.
+ let data = r#"{
+ "name": "John Doe",
+ "age": 43,
+ "phones": [
+ "+44 1234567",
+ "+44 2345678"
+ ]
+ }"#;
+
+ // Parse the string of data into serde_json::Value.
+ let v: Value = serde_json::from_str(data)?;
+
+ // Access parts of the data by indexing with square brackets.
+ println!("Please call {} at the number {}", v["name"], v["phones"][0]);
+
+ Ok(())
+}
+```
+
+The result of square bracket indexing like `v["name"]` is a borrow of the data
+at that index, so the type is `&Value`. A JSON map can be indexed with string
+keys, while a JSON array can be indexed with integer keys. If the type of the
+data is not right for the type with which it is being indexed, or if a map does
+not contain the key being indexed, or if the index into a vector is out of
+bounds, the returned element is `Value::Null`.
+
+When a `Value` is printed, it is printed as a JSON string. So in the code above,
+the output looks like `Please call "John Doe" at the number "+44 1234567"`. The
+quotation marks appear because `v["name"]` is a `&Value` containing a JSON
+string and its JSON representation is `"John Doe"`. Printing as a plain string
+without quotation marks involves converting from a JSON string to a Rust string
+with [`as_str()`] or avoiding the use of `Value` as described in the following
+section.
+
+[`as_str()`]: https://docs.serde.rs/serde_json/enum.Value.html#method.as_str
+
+The `Value` representation is sufficient for very basic tasks but can be tedious
+to work with for anything more significant. Error handling is verbose to
+implement correctly, for example imagine trying to detect the presence of
+unrecognized fields in the input data. The compiler is powerless to help you
+when you make a mistake, for example imagine typoing `v["name"]` as `v["nmae"]`
+in one of the dozens of places it is used in your code.
+
+## Parsing JSON as strongly typed data structures
+
+Serde provides a powerful way of mapping JSON data into Rust data structures
+largely automatically.
+
+<a href="http://play.integer32.com/?gist=cff572b80d3f078c942a2151e6020adc" target="_blank">
+<img align="right" width="50" src="https://raw.githubusercontent.com/serde-rs/serde-rs.github.io/master/img/run.png">
+</a>
+
+```rust
+extern crate serde;
+extern crate serde_json;
+
+#[macro_use]
+extern crate serde_derive;
+
+use serde_json::Error;
+
+#[derive(Serialize, Deserialize)]
+struct Person {
+ name: String,
+ age: u8,
+ phones: Vec<String>,
+}
+
+fn typed_example() -> Result<(), Error> {
+ // Some JSON input data as a &str. Maybe this comes from the user.
+ let data = r#"{
+ "name": "John Doe",
+ "age": 43,
+ "phones": [
+ "+44 1234567",
+ "+44 2345678"
+ ]
+ }"#;
+
+ // Parse the string of data into a Person object. This is exactly the
+ // same function as the one that produced serde_json::Value above, but
+ // now we are asking it for a Person as output.
+ let p: Person = serde_json::from_str(data)?;
+
+ // Do things just like with any other Rust data structure.
+ println!("Please call {} at the number {}", p.name, p.phones[0]);
+
+ Ok(())
+}
+```
+
+This is the same `serde_json::from_str` function as before, but this time we
+assign the return value to a variable of type `Person` so Serde will
+automatically interpret the input data as a `Person` and produce informative
+error messages if the layout does not conform to what a `Person` is expected
+to look like.
+
+Any type that implements Serde's `Deserialize` trait can be deserialized
+this way. This includes built-in Rust standard library types like `Vec<T>`
+and `HashMap<K, V>`, as well as any structs or enums annotated with
+`#[derive(Deserialize)]`.
+
+Once we have `p` of type `Person`, our IDE and the Rust compiler can help us
+use it correctly like they do for any other Rust code. The IDE can
+autocomplete field names to prevent typos, which was impossible in the
+`serde_json::Value` representation. And the Rust compiler can check that
+when we write `p.phones[0]`, then `p.phones` is guaranteed to be a
+`Vec<String>` so indexing into it makes sense and produces a `String`.
+
+## Constructing JSON values
+
+Serde JSON provides a [`json!` macro][macro] to build `serde_json::Value`
+objects with very natural JSON syntax. In order to use this macro,
+`serde_json` needs to be imported with the `#[macro_use]` attribute.
+
+<a href="http://play.integer32.com/?gist=c216d6beabd9429a6ac13b8f88938dfe" target="_blank">
+<img align="right" width="50" src="https://raw.githubusercontent.com/serde-rs/serde-rs.github.io/master/img/run.png">
+</a>
+
+```rust
+#[macro_use]
+extern crate serde_json;
+
+fn main() {
+ // The type of `john` is `serde_json::Value`
+ let john = json!({
+ "name": "John Doe",
+ "age": 43,
+ "phones": [
+ "+44 1234567",
+ "+44 2345678"
+ ]
+ });
+
+ println!("first phone number: {}", john["phones"][0]);
+
+ // Convert to a string of JSON and print it out
+ println!("{}", john.to_string());
+}
+```
+
+The `Value::to_string()` function converts a `serde_json::Value` into a
+`String` of JSON text.
+
+One neat thing about the `json!` macro is that variables and expressions can
+be interpolated directly into the JSON value as you are building it. Serde
+will check at compile time that the value you are interpolating is able to
+be represented as JSON.
+
+<a href="http://play.integer32.com/?gist=aae3af4d274bd249d1c8a947076355f2" target="_blank">
+<img align="right" width="50" src="https://raw.githubusercontent.com/serde-rs/serde-rs.github.io/master/img/run.png">
+</a>
+
+```rust
+let full_name = "John Doe";
+let age_last_year = 42;
+
+// The type of `john` is `serde_json::Value`
+let john = json!({
+ "name": full_name,
+ "age": age_last_year + 1,
+ "phones": [
+ format!("+44 {}", random_phone())
+ ]
+});
+```
+
+This is amazingly convenient but we have the problem we had before with
+`Value` which is that the IDE and Rust compiler cannot help us if we get it
+wrong. Serde JSON provides a better way of serializing strongly-typed data
+structures into JSON text.
+
+## Creating JSON by serializing data structures
+
+A data structure can be converted to a JSON string by
+[`serde_json::to_string`][to_string]. There is also
+[`serde_json::to_vec`][to_vec] which serializes to a `Vec<u8>` and
+[`serde_json::to_writer`][to_writer] which serializes to any `io::Write`
+such as a File or a TCP stream.
+
+<a href="http://play.integer32.com/?gist=40967ece79921c77fd78ebc8f177c063" target="_blank">
+<img align="right" width="50" src="https://raw.githubusercontent.com/serde-rs/serde-rs.github.io/master/img/run.png">
+</a>
+
+```rust
+extern crate serde;
+extern crate serde_json;
+
+#[macro_use]
+extern crate serde_derive;
+
+use serde_json::Error;
+
+#[derive(Serialize, Deserialize)]
+struct Address {
+ street: String,
+ city: String,
+}
+
+fn print_an_address() -> Result<(), Error> {
+ // Some data structure.
+ let address = Address {
+ street: "10 Downing Street".to_owned(),
+ city: "London".to_owned(),
+ };
+
+ // Serialize it to a JSON string.
+ let j = serde_json::to_string(&address)?;
+
+ // Print, write to a file, or send to an HTTP server.
+ println!("{}", j);
+
+ Ok(())
+}
+```
+
+Any type that implements Serde's `Serialize` trait can be serialized this
+way. This includes built-in Rust standard library types like `Vec<T>` and
+`HashMap<K, V>`, as well as any structs or enums annotated with
+`#[derive(Serialize)]`.
+
+## Performance
+
+It is fast. You should expect in the ballpark of 500 to 1000 megabytes per
+second deserialization and 600 to 900 megabytes per second serialization,
+depending on the characteristics of your data. This is competitive with the
+fastest C and C++ JSON libraries or even 30% faster for many use cases.
+Benchmarks live in the [serde-rs/json-benchmark] repo.
+
+[serde-rs/json-benchmark]: https://github.com/serde-rs/json-benchmark
+
+## Getting help
+
+Serde developers live in the #serde channel on
+[`irc.mozilla.org`](https://wiki.mozilla.org/IRC). The #rust channel is also a
+good resource with generally faster response time but less specific knowledge
+about Serde. If IRC is not your thing, we are happy to respond to [GitHub
+issues](https://github.com/serde-rs/json/issues/new) as well.
+
+## No-std support
+
+This crate currently requires the Rust standard library. For JSON support in
+Serde without a standard library, please see the [`serde-json-core`] crate.
+
+[`serde-json-core`]: https://japaric.github.io/serde-json-core/serde_json_core/
+
+## License
+
+Serde JSON is licensed under either of
+
+ * Apache License, Version 2.0, ([LICENSE-APACHE](LICENSE-APACHE) or
+ http://www.apache.org/licenses/LICENSE-2.0)
+ * MIT license ([LICENSE-MIT](LICENSE-MIT) or
+ http://opensource.org/licenses/MIT)
+
+at your option.
+
+### Contribution
+
+Unless you explicitly state otherwise, any contribution intentionally submitted
+for inclusion in Serde JSON by you, as defined in the Apache-2.0 license, shall
+be dual licensed as above, without any additional terms or conditions.
+
+[value]: https://docs.serde.rs/serde_json/value/enum.Value.html
+[from_str]: https://docs.serde.rs/serde_json/de/fn.from_str.html
+[from_slice]: https://docs.serde.rs/serde_json/de/fn.from_slice.html
+[from_reader]: https://docs.serde.rs/serde_json/de/fn.from_reader.html
+[to_string]: https://docs.serde.rs/serde_json/ser/fn.to_string.html
+[to_vec]: https://docs.serde.rs/serde_json/ser/fn.to_vec.html
+[to_writer]: https://docs.serde.rs/serde_json/ser/fn.to_writer.html
+[macro]: https://docs.serde.rs/serde_json/macro.json.html
new file mode 100644
--- /dev/null
+++ b/third_party/rust/serde_json/src/de.rs
@@ -0,0 +1,2265 @@
+// Copyright 2017 Serde Developers
+//
+// Licensed under the Apache License, Version 2.0 <LICENSE-APACHE or
+// http://www.apache.org/licenses/LICENSE-2.0> or the MIT license
+// <LICENSE-MIT or http://opensource.org/licenses/MIT>, at your
+// option. This file may not be copied, modified, or distributed
+// except according to those terms.
+
+//! Deserialize JSON data to a Rust data structure.
+
+use std::io;
+use std::marker::PhantomData;
+use std::result;
+use std::str::FromStr;
+use std::{i32, u64};
+
+use serde::de::{self, Expected, Unexpected};
+
+use super::error::{Error, ErrorCode, Result};
+
+use read::{self, Reference};
+
+pub use read::{IoRead, Read, SliceRead, StrRead};
+
+use number::Number;
+#[cfg(feature = "arbitrary_precision")]
+use number::NumberDeserializer;
+
+//////////////////////////////////////////////////////////////////////////////
+
+/// A structure that deserializes JSON into Rust values.
+pub struct Deserializer<R> {
+ read: R,
+ str_buf: Vec<u8>,
+ remaining_depth: u8,
+}
+
+impl<'de, R> Deserializer<R>
+where
+ R: read::Read<'de>,
+{
+ /// Create a JSON deserializer from one of the possible serde_json input
+ /// sources.
+ ///
+ /// Typically it is more convenient to use one of these methods instead:
+ ///
+ /// - Deserializer::from_str
+ /// - Deserializer::from_bytes
+ /// - Deserializer::from_reader
+ pub fn new(read: R) -> Self {
+ Deserializer {
+ read: read,
+ str_buf: Vec::with_capacity(128),
+ remaining_depth: 128,
+ }
+ }
+}
+
+impl<R> Deserializer<read::IoRead<R>>
+where
+ R: io::Read,
+{
+ /// Creates a JSON deserializer from an `io::Read`.
+ pub fn from_reader(reader: R) -> Self {
+ Deserializer::new(read::IoRead::new(reader))
+ }
+}
+
+impl<'a> Deserializer<read::SliceRead<'a>> {
+ /// Creates a JSON deserializer from a `&[u8]`.
+ pub fn from_slice(bytes: &'a [u8]) -> Self {
+ Deserializer::new(read::SliceRead::new(bytes))
+ }
+}
+
+impl<'a> Deserializer<read::StrRead<'a>> {
+ /// Creates a JSON deserializer from a `&str`.
+ pub fn from_str(s: &'a str) -> Self {
+ Deserializer::new(read::StrRead::new(s))
+ }
+}
+
+macro_rules! overflow {
+ ($a:ident * 10 + $b:ident, $c:expr) => {
+ $a >= $c / 10 && ($a > $c / 10 || $b > $c % 10)
+ };
+}
+
+// Not public API. Should be pub(crate).
+#[doc(hidden)]
+pub enum ParserNumber {
+ F64(f64),
+ U64(u64),
+ I64(i64),
+ #[cfg(feature = "arbitrary_precision")]
+ String(String),
+}
+
+impl ParserNumber {
+ fn visit<'de, V>(self, visitor: V) -> Result<V::Value>
+ where
+ V: de::Visitor<'de>,
+ {
+ match self {
+ ParserNumber::F64(x) => visitor.visit_f64(x),
+ ParserNumber::U64(x) => visitor.visit_u64(x),
+ ParserNumber::I64(x) => visitor.visit_i64(x),
+ #[cfg(feature = "arbitrary_precision")]
+ ParserNumber::String(x) => visitor.visit_map(NumberDeserializer { number: x.into() }),
+ }
+ }
+
+ fn invalid_type(self, exp: &Expected) -> Error {
+ match self {
+ ParserNumber::F64(x) => de::Error::invalid_type(Unexpected::Float(x), exp),
+ ParserNumber::U64(x) => de::Error::invalid_type(Unexpected::Unsigned(x), exp),
+ ParserNumber::I64(x) => de::Error::invalid_type(Unexpected::Signed(x), exp),
+ #[cfg(feature = "arbitrary_precision")]
+ ParserNumber::String(_) => de::Error::invalid_type(Unexpected::Other("number"), exp),
+ }
+ }
+}
+
+impl<'de, R: Read<'de>> Deserializer<R> {
+ /// The `Deserializer::end` method should be called after a value has been fully deserialized.
+ /// This allows the `Deserializer` to validate that the input stream is at the end or that it
+ /// only has trailing whitespace.
+ pub fn end(&mut self) -> Result<()> {
+ match try!(self.parse_whitespace()) {
+ Some(_) => Err(self.peek_error(ErrorCode::TrailingCharacters)),
+ None => Ok(()),
+ }
+ }
+
+ /// Turn a JSON deserializer into an iterator over values of type T.
+ pub fn into_iter<T>(self) -> StreamDeserializer<'de, R, T>
+ where
+ T: de::Deserialize<'de>,
+ {
+ // This cannot be an implementation of std::iter::IntoIterator because
+ // we need the caller to choose what T is.
+ let offset = self.read.byte_offset();
+ StreamDeserializer {
+ de: self,
+ offset: offset,
+ output: PhantomData,
+ lifetime: PhantomData,
+ }
+ }
+
+ fn peek(&mut self) -> Result<Option<u8>> {
+ self.read.peek().map_err(Error::io)
+ }
+
+ fn peek_or_null(&mut self) -> Result<u8> {
+ Ok(try!(self.peek()).unwrap_or(b'\x00'))
+ }
+
+ fn eat_char(&mut self) {
+ self.read.discard();
+ }
+
+ fn next_char(&mut self) -> Result<Option<u8>> {
+ self.read.next().map_err(Error::io)
+ }
+
+ fn next_char_or_null(&mut self) -> Result<u8> {
+ Ok(try!(self.next_char()).unwrap_or(b'\x00'))
+ }
+
+ /// Error caused by a byte from next_char().
+ #[cold]
+ fn error(&self, reason: ErrorCode) -> Error {
+ let position = self.read.position();
+ Error::syntax(reason, position.line, position.column)
+ }
+
+ /// Error caused by a byte from peek().
+ #[cold]
+ fn peek_error(&self, reason: ErrorCode) -> Error {
+ let position = self.read.peek_position();
+ Error::syntax(reason, position.line, position.column)
+ }
+
+ /// Returns the first non-whitespace byte without consuming it, or `None` if
+ /// EOF is encountered.
+ fn parse_whitespace(&mut self) -> Result<Option<u8>> {
+ loop {
+ match try!(self.peek()) {
+ Some(b' ') | Some(b'\n') | Some(b'\t') | Some(b'\r') => {
+ self.eat_char();
+ }
+ other => {
+ return Ok(other);
+ }
+ }
+ }
+ }
+
+ #[cold]
+ fn peek_invalid_type(&mut self, exp: &Expected) -> Error {
+ let err = match self.peek_or_null().unwrap_or(b'\x00') {
+ b'n' => {
+ self.eat_char();
+ if let Err(err) = self.parse_ident(b"ull") {
+ return err;
+ }
+ de::Error::invalid_type(Unexpected::Unit, exp)
+ }
+ b't' => {
+ self.eat_char();
+ if let Err(err) = self.parse_ident(b"rue") {
+ return err;
+ }
+ de::Error::invalid_type(Unexpected::Bool(true), exp)
+ }
+ b'f' => {
+ self.eat_char();
+ if let Err(err) = self.parse_ident(b"alse") {
+ return err;
+ }
+ de::Error::invalid_type(Unexpected::Bool(false), exp)
+ }
+ b'-' => {
+ self.eat_char();
+ match self.parse_any_number(false) {
+ Ok(n) => n.invalid_type(exp),
+ Err(err) => return err,
+ }
+ }
+ b'0'...b'9' => match self.parse_any_number(true) {
+ Ok(n) => n.invalid_type(exp),
+ Err(err) => return err,
+ },
+ b'"' => {
+ self.eat_char();
+ self.str_buf.clear();
+ match self.read.parse_str(&mut self.str_buf) {
+ Ok(s) => de::Error::invalid_type(Unexpected::Str(&s), exp),
+ Err(err) => return err,
+ }
+ }
+ b'[' => de::Error::invalid_type(Unexpected::Seq, exp),
+ b'{' => de::Error::invalid_type(Unexpected::Map, exp),
+ _ => self.peek_error(ErrorCode::ExpectedSomeValue),
+ };
+
+ self.fix_position(err)
+ }
+
+ fn deserialize_prim_number<V>(&mut self, visitor: V) -> Result<V::Value>
+ where
+ V: de::Visitor<'de>,
+ {
+ let peek = match try!(self.parse_whitespace()) {
+ Some(b) => b,
+ None => {
+ return Err(self.peek_error(ErrorCode::EofWhileParsingValue));
+ }
+ };
+
+ let value = match peek {
+ b'-' => {
+ self.eat_char();
+ try!(self.parse_integer(false)).visit(visitor)
+ }
+ b'0'...b'9' => try!(self.parse_integer(true)).visit(visitor),
+ _ => Err(self.peek_invalid_type(&visitor)),
+ };
+
+ match value {
+ Ok(value) => Ok(value),
+ Err(err) => Err(self.fix_position(err)),
+ }
+ }
+
+ serde_if_integer128! {
+ fn scan_integer128(&mut self, buf: &mut String) -> Result<()> {
+ match try!(self.next_char_or_null()) {
+ b'0' => {
+ buf.push('0');
+ // There can be only one leading '0'.
+ match try!(self.peek_or_null()) {
+ b'0'...b'9' => {
+ Err(self.peek_error(ErrorCode::InvalidNumber))
+ }
+ _ => Ok(()),
+ }
+ }
+ c @ b'1'...b'9' => {
+ buf.push(c as char);
+ while let c @ b'0'...b'9' = try!(self.peek_or_null()) {
+ self.eat_char();
+ buf.push(c as char);
+ }
+ Ok(())
+ }
+ _ => {
+ Err(self.error(ErrorCode::InvalidNumber))
+ }
+ }
+ }
+ }
+
+ #[cold]
+ fn fix_position(&self, err: Error) -> Error {
+ err.fix_position(move |code| self.error(code))
+ }
+
+ fn parse_ident(&mut self, ident: &[u8]) -> Result<()> {
+ for expected in ident {
+ match try!(self.next_char()) {
+ None => {
+ return Err(self.error(ErrorCode::EofWhileParsingValue));
+ }
+ Some(next) => {
+ if next != *expected {
+ return Err(self.error(ErrorCode::ExpectedSomeIdent));
+ }
+ }
+ }
+ }
+
+ Ok(())
+ }
+
+ fn parse_integer(&mut self, positive: bool) -> Result<ParserNumber> {
+ match try!(self.next_char_or_null()) {
+ b'0' => {
+ // There can be only one leading '0'.
+ match try!(self.peek_or_null()) {
+ b'0'...b'9' => Err(self.peek_error(ErrorCode::InvalidNumber)),
+ _ => self.parse_number(positive, 0),
+ }
+ }
+ c @ b'1'...b'9' => {
+ let mut res = (c - b'0') as u64;
+
+ loop {
+ match try!(self.peek_or_null()) {
+ c @ b'0'...b'9' => {
+ self.eat_char();
+ let digit = (c - b'0') as u64;
+
+ // We need to be careful with overflow. If we can, try to keep the
+ // number as a `u64` until we grow too large. At that point, switch to
+ // parsing the value as a `f64`.
+ if overflow!(res * 10 + digit, u64::max_value()) {
+ return Ok(ParserNumber::F64(try!(
+ self.parse_long_integer(
+ positive,
+ res,
+ 1, // res * 10^1
+ )
+ )));
+ }
+
+ res = res * 10 + digit;
+ }
+ _ => {
+ return self.parse_number(positive, res);
+ }
+ }
+ }
+ }
+ _ => Err(self.error(ErrorCode::InvalidNumber)),
+ }
+ }
+
+ fn parse_long_integer(
+ &mut self,
+ positive: bool,
+ significand: u64,
+ mut exponent: i32,
+ ) -> Result<f64> {
+ loop {
+ match try!(self.peek_or_null()) {
+ b'0'...b'9' => {
+ self.eat_char();
+ // This could overflow... if your integer is gigabytes long.
+ // Ignore that possibility.
+ exponent += 1;
+ }
+ b'.' => {
+ return self.parse_decimal(positive, significand, exponent);
+ }
+ b'e' | b'E' => {
+ return self.parse_exponent(positive, significand, exponent);
+ }
+ _ => {
+ return self.f64_from_parts(positive, significand, exponent);
+ }
+ }
+ }
+ }
+
+ fn parse_number(&mut self, positive: bool, significand: u64) -> Result<ParserNumber> {
+ Ok(match try!(self.peek_or_null()) {
+ b'.' => ParserNumber::F64(try!(self.parse_decimal(positive, significand, 0))),
+ b'e' | b'E' => ParserNumber::F64(try!(self.parse_exponent(positive, significand, 0))),
+ _ => {
+ if positive {
+ ParserNumber::U64(significand)
+ } else {
+ let neg = (significand as i64).wrapping_neg();
+
+ // Convert into a float if we underflow.
+ if neg > 0 {
+ ParserNumber::F64(-(significand as f64))
+ } else {
+ ParserNumber::I64(neg)
+ }
+ }
+ }
+ })
+ }
+
+ fn parse_decimal(
+ &mut self,
+ positive: bool,
+ mut significand: u64,
+ mut exponent: i32,
+ ) -> Result<f64> {
+ self.eat_char();
+
+ let mut at_least_one_digit = false;
+ while let c @ b'0'...b'9' = try!(self.peek_or_null()) {
+ self.eat_char();
+ let digit = (c - b'0') as u64;
+ at_least_one_digit = true;
+
+ if overflow!(significand * 10 + digit, u64::max_value()) {
+ // The next multiply/add would overflow, so just ignore all
+ // further digits.
+ while let b'0'...b'9' = try!(self.peek_or_null()) {
+ self.eat_char();
+ }
+ break;
+ }
+
+ significand = significand * 10 + digit;
+ exponent -= 1;
+ }
+
+ if !at_least_one_digit {
+ return Err(self.peek_error(ErrorCode::InvalidNumber));
+ }
+
+ match try!(self.peek_or_null()) {
+ b'e' | b'E' => self.parse_exponent(positive, significand, exponent),
+ _ => self.f64_from_parts(positive, significand, exponent),
+ }
+ }
+
+ fn parse_exponent(
+ &mut self,
+ positive: bool,
+ significand: u64,
+ starting_exp: i32,
+ ) -> Result<f64> {
+ self.eat_char();
+
+ let positive_exp = match try!(self.peek_or_null()) {
+ b'+' => {
+ self.eat_char();
+ true
+ }
+ b'-' => {
+ self.eat_char();
+ false
+ }
+ _ => true,
+ };
+
+ // Make sure a digit follows the exponent place.
+ let mut exp = match try!(self.next_char_or_null()) {
+ c @ b'0'...b'9' => (c - b'0') as i32,
+ _ => {
+ return Err(self.error(ErrorCode::InvalidNumber));
+ }
+ };
+
+ while let c @ b'0'...b'9' = try!(self.peek_or_null()) {
+ self.eat_char();
+ let digit = (c - b'0') as i32;
+
+ if overflow!(exp * 10 + digit, i32::max_value()) {
+ return self.parse_exponent_overflow(positive, significand, positive_exp);
+ }
+
+ exp = exp * 10 + digit;
+ }
+
+ let final_exp = if positive_exp {
+ starting_exp.saturating_add(exp)
+ } else {
+ starting_exp.saturating_sub(exp)
+ };
+
+ self.f64_from_parts(positive, significand, final_exp)
+ }
+
+ // This cold code should not be inlined into the middle of the hot
+ // exponent-parsing loop above.
+ #[cold]
+ #[inline(never)]
+ fn parse_exponent_overflow(
+ &mut self,
+ positive: bool,
+ significand: u64,
+ positive_exp: bool,
+ ) -> Result<f64> {
+ // Error instead of +/- infinity.
+ if significand != 0 && positive_exp {
+ return Err(self.error(ErrorCode::NumberOutOfRange));
+ }
+
+ while let b'0'...b'9' = try!(self.peek_or_null()) {
+ self.eat_char();
+ }
+ Ok(if positive { 0.0 } else { -0.0 })
+ }
+
+ fn parse_any_signed_number(&mut self) -> Result<ParserNumber> {
+ let peek = match try!(self.peek()) {
+ Some(b) => b,
+ None => {
+ return Err(self.peek_error(ErrorCode::EofWhileParsingValue));
+ }
+ };
+
+ let value = match peek {
+ b'-' => {
+ self.eat_char();
+ self.parse_any_number(false)
+ }
+ b'0'...b'9' => self.parse_any_number(true),
+ _ => Err(self.peek_error(ErrorCode::InvalidNumber)),
+ };
+
+ let value = match try!(self.peek()) {
+ Some(_) => Err(self.peek_error(ErrorCode::InvalidNumber)),
+ None => value,
+ };
+
+ match value {
+ Ok(value) => Ok(value),
+ // The de::Error impl creates errors with unknown line and column.
+ // Fill in the position here by looking at the current index in the
+ // input. There is no way to tell whether this should call `error`
+ // or `peek_error` so pick the one that seems correct more often.
+ // Worst case, the position is off by one character.
+ Err(err) => Err(self.fix_position(err)),
+ }
+ }
+
+ #[cfg(not(feature = "arbitrary_precision"))]
+ fn parse_any_number(&mut self, positive: bool) -> Result<ParserNumber> {
+ self.parse_integer(positive)
+ }
+
+ #[cfg(feature = "arbitrary_precision")]
+ fn parse_any_number(&mut self, positive: bool) -> Result<ParserNumber> {
+ let mut buf = String::with_capacity(16);
+ if !positive {
+ buf.push('-');
+ }
+ self.scan_integer(&mut buf)?;
+ Ok(ParserNumber::String(buf))
+ }
+
+ #[cfg(feature = "arbitrary_precision")]
+ fn scan_or_null(&mut self, buf: &mut String) -> Result<u8> {
+ match try!(self.next_char()) {
+ Some(b) => {
+ buf.push(b as char);
+ Ok(b)
+ }
+ None => Ok(b'\x00'),
+ }
+ }
+
+ #[cfg(feature = "arbitrary_precision")]
+ fn scan_integer(&mut self, buf: &mut String) -> Result<()> {
+ match try!(self.scan_or_null(buf)) {
+ b'0' => {
+ // There can be only one leading '0'.
+ match try!(self.peek_or_null()) {
+ b'0'...b'9' => Err(self.peek_error(ErrorCode::InvalidNumber)),
+ _ => self.scan_number(buf),
+ }
+ }
+ b'1'...b'9' => loop {
+ match try!(self.peek_or_null()) {
+ c @ b'0'...b'9' => {
+ self.eat_char();
+ buf.push(c as char);
+ }
+ _ => {
+ return self.scan_number(buf);
+ }
+ }
+ },
+ _ => Err(self.error(ErrorCode::InvalidNumber)),
+ }
+ }
+
+ #[cfg(feature = "arbitrary_precision")]
+ fn scan_number(&mut self, buf: &mut String) -> Result<()> {
+ match try!(self.peek_or_null()) {
+ b'.' => self.scan_decimal(buf),
+ b'e' | b'E' => self.scan_exponent(buf),
+ _ => Ok(()),
+ }
+ }
+
+ #[cfg(feature = "arbitrary_precision")]
+ fn scan_decimal(&mut self, buf: &mut String) -> Result<()> {
+ self.eat_char();
+ buf.push('.');
+
+ let mut at_least_one_digit = false;
+ while let c @ b'0'...b'9' = try!(self.peek_or_null()) {
+ self.eat_char();
+ buf.push(c as char);
+ at_least_one_digit = true;
+ }
+
+ if !at_least_one_digit {
+ return Err(self.peek_error(ErrorCode::InvalidNumber));
+ }
+
+ match try!(self.peek_or_null()) {
+ b'e' | b'E' => self.scan_exponent(buf),
+ _ => Ok(()),
+ }
+ }
+
+ #[cfg(feature = "arbitrary_precision")]
+ fn scan_exponent(&mut self, buf: &mut String) -> Result<()> {
+ self.eat_char();
+ buf.push('e');
+
+ match try!(self.peek_or_null()) {
+ b'+' => {
+ self.eat_char();
+ }
+ b'-' => {
+ self.eat_char();
+ buf.push('-');
+ }
+ _ => {}
+ }
+
+ // Make sure a digit follows the exponent place.
+ match try!(self.scan_or_null(buf)) {
+ b'0'...b'9' => {}
+ _ => {
+ return Err(self.error(ErrorCode::InvalidNumber));
+ }
+ }
+
+ while let c @ b'0'...b'9' = try!(self.peek_or_null()) {
+ self.eat_char();
+ buf.push(c as char);
+ }
+
+ Ok(())
+ }
+
+ fn f64_from_parts(
+ &mut self,
+ positive: bool,
+ significand: u64,
+ mut exponent: i32,
+ ) -> Result<f64> {
+ let mut f = significand as f64;
+ loop {
+ match POW10.get(exponent.abs() as usize) {
+ Some(&pow) => {
+ if exponent >= 0 {
+ f *= pow;
+ if f.is_infinite() {
+ return Err(self.error(ErrorCode::NumberOutOfRange));
+ }
+ } else {
+ f /= pow;
+ }
+ break;
+ }
+ None => {
+ if f == 0.0 {
+ break;
+ }
+ if exponent >= 0 {
+ return Err(self.error(ErrorCode::NumberOutOfRange));
+ }
+ f /= 1e308;
+ exponent += 308;
+ }
+ }
+ }
+ Ok(if positive { f } else { -f })
+ }
+
+ fn parse_object_colon(&mut self) -> Result<()> {
+ match try!(self.parse_whitespace()) {
+ Some(b':') => {
+ self.eat_char();
+ Ok(())
+ }
+ Some(_) => Err(self.peek_error(ErrorCode::ExpectedColon)),
+ None => Err(self.peek_error(ErrorCode::EofWhileParsingObject)),
+ }
+ }
+
+ fn end_seq(&mut self) -> Result<()> {
+ match try!(self.parse_whitespace()) {
+ Some(b']') => {
+ self.eat_char();
+ Ok(())
+ }
+ Some(b',') => {
+ self.eat_char();
+ match self.parse_whitespace() {
+ Ok(Some(b']')) => Err(self.peek_error(ErrorCode::TrailingComma)),
+ _ => Err(self.peek_error(ErrorCode::TrailingCharacters)),
+ }
+ }
+ Some(_) => Err(self.peek_error(ErrorCode::TrailingCharacters)),
+ None => Err(self.peek_error(ErrorCode::EofWhileParsingList)),
+ }
+ }
+
+ fn end_map(&mut self) -> Result<()> {
+ match try!(self.parse_whitespace()) {
+ Some(b'}') => {
+ self.eat_char();
+ Ok(())
+ }
+ Some(b',') => Err(self.peek_error(ErrorCode::TrailingComma)),
+ Some(_) => Err(self.peek_error(ErrorCode::TrailingCharacters)),
+ None => Err(self.peek_error(ErrorCode::EofWhileParsingObject)),
+ }
+ }
+
+ fn ignore_value(&mut self) -> Result<()> {
+ let peek = match try!(self.parse_whitespace()) {
+ Some(b) => b,
+ None => {
+ return Err(self.peek_error(ErrorCode::EofWhileParsingValue));
+ }
+ };
+
+ match peek {
+ b'n' => {
+ self.eat_char();
+ self.parse_ident(b"ull")
+ }
+ b't' => {
+ self.eat_char();
+ self.parse_ident(b"rue")
+ }
+ b'f' => {
+ self.eat_char();
+ self.parse_ident(b"alse")
+ }
+ b'-' => {
+ self.eat_char();
+ self.ignore_integer()
+ }
+ b'0'...b'9' => self.ignore_integer(),
+ b'"' => {
+ self.eat_char();
+ self.read.ignore_str()
+ }
+ b'[' => {
+ self.remaining_depth -= 1;
+ if self.remaining_depth == 0 {
+ return Err(self.peek_error(ErrorCode::RecursionLimitExceeded));
+ }
+
+ self.eat_char();
+ let res = self.ignore_seq();
+ self.remaining_depth += 1;
+ res
+ }
+ b'{' => {
+ self.remaining_depth -= 1;
+ if self.remaining_depth == 0 {
+ return Err(self.peek_error(ErrorCode::RecursionLimitExceeded));
+ }
+
+ self.eat_char();
+ let res = self.ignore_map();
+ self.remaining_depth += 1;
+ res
+ }
+ _ => Err(self.peek_error(ErrorCode::ExpectedSomeValue)),
+ }
+ }
+
+ fn ignore_integer(&mut self) -> Result<()> {
+ match try!(self.next_char_or_null()) {
+ b'0' => {
+ // There can be only one leading '0'.
+ if let b'0'...b'9' = try!(self.peek_or_null()) {
+ return Err(self.peek_error(ErrorCode::InvalidNumber));
+ }
+ }
+ b'1'...b'9' => while let b'0'...b'9' = try!(self.peek_or_null()) {
+ self.eat_char();
+ },
+ _ => {
+ return Err(self.error(ErrorCode::InvalidNumber));
+ }
+ }
+
+ match try!(self.peek_or_null()) {
+ b'.' => self.ignore_decimal(),
+ b'e' | b'E' => self.ignore_exponent(),
+ _ => Ok(()),
+ }
+ }
+
+ fn ignore_decimal(&mut self) -> Result<()> {
+ self.eat_char();
+
+ let mut at_least_one_digit = false;
+ while let b'0'...b'9' = try!(self.peek_or_null()) {
+ self.eat_char();
+ at_least_one_digit = true;
+ }
+
+ if !at_least_one_digit {
+ return Err(self.peek_error(ErrorCode::InvalidNumber));
+ }
+
+ match try!(self.peek_or_null()) {
+ b'e' | b'E' => self.ignore_exponent(),
+ _ => Ok(()),
+ }
+ }
+
+ fn ignore_exponent(&mut self) -> Result<()> {
+ self.eat_char();
+
+ match try!(self.peek_or_null()) {
+ b'+' | b'-' => self.eat_char(),
+ _ => {}
+ }
+
+ // Make sure a digit follows the exponent place.
+ match try!(self.next_char_or_null()) {
+ b'0'...b'9' => {}
+ _ => {
+ return Err(self.error(ErrorCode::InvalidNumber));
+ }
+ }
+
+ while let b'0'...b'9' = try!(self.peek_or_null()) {
+ self.eat_char();
+ }
+
+ Ok(())
+ }
+
+ fn ignore_seq(&mut self) -> Result<()> {
+ let mut first = true;
+
+ loop {
+ match try!(self.parse_whitespace()) {
+ Some(b']') => {
+ self.eat_char();
+ return Ok(());
+ }
+ Some(b',') if !first => {
+ self.eat_char();
+ }
+ Some(_) => {
+ if first {
+ first = false;
+ } else {
+ return Err(self.peek_error(ErrorCode::ExpectedListCommaOrEnd));
+ }
+ }
+ None => {
+ return Err(self.peek_error(ErrorCode::EofWhileParsingList));
+ }
+ }
+
+ try!(self.ignore_value());
+ }
+ }
+
+ fn ignore_map(&mut self) -> Result<()> {
+ let mut first = true;
+
+ loop {
+ let peek = match try!(self.parse_whitespace()) {
+ Some(b'}') => {
+ self.eat_char();
+ return Ok(());
+ }
+ Some(b',') if !first => {
+ self.eat_char();
+ try!(self.parse_whitespace())
+ }
+ Some(b) => {
+ if first {
+ first = false;
+ Some(b)
+ } else {
+ return Err(self.peek_error(ErrorCode::ExpectedObjectCommaOrEnd));
+ }
+ }
+ None => {
+ return Err(self.peek_error(ErrorCode::EofWhileParsingObject));
+ }
+ };
+
+ match peek {
+ Some(b'"') => {
+ self.eat_char();
+ try!(self.read.ignore_str());
+ }
+ Some(_) => {
+ return Err(self.peek_error(ErrorCode::KeyMustBeAString));
+ }
+ None => {
+ return Err(self.peek_error(ErrorCode::EofWhileParsingObject));
+ }
+ }
+
+ match try!(self.parse_whitespace()) {
+ Some(b':') => {
+ self.eat_char();
+ try!(self.ignore_value());
+ }
+ Some(_) => {
+ return Err(self.peek_error(ErrorCode::ExpectedColon));
+ }
+ None => {
+ return Err(self.peek_error(ErrorCode::EofWhileParsingObject));
+ }
+ }
+ }
+ }
+}
+
+impl FromStr for Number {
+ type Err = Error;
+
+ fn from_str(s: &str) -> result::Result<Self, Self::Err> {
+ Deserializer::from_str(s)
+ .parse_any_signed_number()
+ .map(Into::into)
+ }
+}
+
+#[cfg_attr(rustfmt, rustfmt_skip)]
+static POW10: [f64; 309] =
+ [1e000, 1e001, 1e002, 1e003, 1e004, 1e005, 1e006, 1e007, 1e008, 1e009,
+ 1e010, 1e011, 1e012, 1e013, 1e014, 1e015, 1e016, 1e017, 1e018, 1e019,
+ 1e020, 1e021, 1e022, 1e023, 1e024, 1e025, 1e026, 1e027, 1e028, 1e029,
+ 1e030, 1e031, 1e032, 1e033, 1e034, 1e035, 1e036, 1e037, 1e038, 1e039,
+ 1e040, 1e041, 1e042, 1e043, 1e044, 1e045, 1e046, 1e047, 1e048, 1e049,
+ 1e050, 1e051, 1e052, 1e053, 1e054, 1e055, 1e056, 1e057, 1e058, 1e059,
+ 1e060, 1e061, 1e062, 1e063, 1e064, 1e065, 1e066, 1e067, 1e068, 1e069,
+ 1e070, 1e071, 1e072, 1e073, 1e074, 1e075, 1e076, 1e077, 1e078, 1e079,
+ 1e080, 1e081, 1e082, 1e083, 1e084, 1e085, 1e086, 1e087, 1e088, 1e089,
+ 1e090, 1e091, 1e092, 1e093, 1e094, 1e095, 1e096, 1e097, 1e098, 1e099,
+ 1e100, 1e101, 1e102, 1e103, 1e104, 1e105, 1e106, 1e107, 1e108, 1e109,
+ 1e110, 1e111, 1e112, 1e113, 1e114, 1e115, 1e116, 1e117, 1e118, 1e119,
+ 1e120, 1e121, 1e122, 1e123, 1e124, 1e125, 1e126, 1e127, 1e128, 1e129,
+ 1e130, 1e131, 1e132, 1e133, 1e134, 1e135, 1e136, 1e137, 1e138, 1e139,
+ 1e140, 1e141, 1e142, 1e143, 1e144, 1e145, 1e146, 1e147, 1e148, 1e149,
+ 1e150, 1e151, 1e152, 1e153, 1e154, 1e155, 1e156, 1e157, 1e158, 1e159,
+ 1e160, 1e161, 1e162, 1e163, 1e164, 1e165, 1e166, 1e167, 1e168, 1e169,
+ 1e170, 1e171, 1e172, 1e173, 1e174, 1e175, 1e176, 1e177, 1e178, 1e179,
+ 1e180, 1e181, 1e182, 1e183, 1e184, 1e185, 1e186, 1e187, 1e188, 1e189,
+ 1e190, 1e191, 1e192, 1e193, 1e194, 1e195, 1e196, 1e197, 1e198, 1e199,
+ 1e200, 1e201, 1e202, 1e203, 1e204, 1e205, 1e206, 1e207, 1e208, 1e209,
+ 1e210, 1e211, 1e212, 1e213, 1e214, 1e215, 1e216, 1e217, 1e218, 1e219,
+ 1e220, 1e221, 1e222, 1e223, 1e224, 1e225, 1e226, 1e227, 1e228, 1e229,
+ 1e230, 1e231, 1e232, 1e233, 1e234, 1e235, 1e236, 1e237, 1e238, 1e239,
+ 1e240, 1e241, 1e242, 1e243, 1e244, 1e245, 1e246, 1e247, 1e248, 1e249,
+ 1e250, 1e251, 1e252, 1e253, 1e254, 1e255, 1e256, 1e257, 1e258, 1e259,
+ 1e260, 1e261, 1e262, 1e263, 1e264, 1e265, 1e266, 1e267, 1e268, 1e269,
+ 1e270, 1e271, 1e272, 1e273, 1e274, 1e275, 1e276, 1e277, 1e278, 1e279,
+ 1e280, 1e281, 1e282, 1e283, 1e284, 1e285, 1e286, 1e287, 1e288, 1e289,
+ 1e290, 1e291, 1e292, 1e293, 1e294, 1e295, 1e296, 1e297, 1e298, 1e299,
+ 1e300, 1e301, 1e302, 1e303, 1e304, 1e305, 1e306, 1e307, 1e308];
+
+macro_rules! deserialize_prim_number {
+ ($method:ident) => {
+ fn $method<V>(self, visitor: V) -> Result<V::Value>
+ where
+ V: de::Visitor<'de>,
+ {
+ self.deserialize_prim_number(visitor)
+ }
+ }
+}
+
+impl<'de, 'a, R: Read<'de>> de::Deserializer<'de> for &'a mut Deserializer<R> {
+ type Error = Error;
+
+ #[inline]
+ fn deserialize_any<V>(self, visitor: V) -> Result<V::Value>
+ where
+ V: de::Visitor<'de>,
+ {
+ let peek = match try!(self.parse_whitespace()) {
+ Some(b) => b,
+ None => {
+ return Err(self.peek_error(ErrorCode::EofWhileParsingValue));
+ }
+ };
+
+ let value = match peek {
+ b'n' => {
+ self.eat_char();
+ try!(self.parse_ident(b"ull"));
+ visitor.visit_unit()
+ }
+ b't' => {
+ self.eat_char();
+ try!(self.parse_ident(b"rue"));
+ visitor.visit_bool(true)
+ }
+ b'f' => {
+ self.eat_char();
+ try!(self.parse_ident(b"alse"));
+ visitor.visit_bool(false)
+ }
+ b'-' => {
+ self.eat_char();
+ try!(self.parse_any_number(false)).visit(visitor)
+ }
+ b'0'...b'9' => try!(self.parse_any_number(true)).visit(visitor),
+ b'"' => {
+ self.eat_char();
+ self.str_buf.clear();
+ match try!(self.read.parse_str(&mut self.str_buf)) {
+ Reference::Borrowed(s) => visitor.visit_borrowed_str(s),
+ Reference::Copied(s) => visitor.visit_str(s),
+ }
+ }
+ b'[' => {
+ self.remaining_depth -= 1;
+ if self.remaining_depth == 0 {
+ return Err(self.peek_error(ErrorCode::RecursionLimitExceeded));
+ }
+
+ self.eat_char();
+ let ret = visitor.visit_seq(SeqAccess::new(self));
+
+ self.remaining_depth += 1;
+
+ match (ret, self.end_seq()) {
+ (Ok(ret), Ok(())) => Ok(ret),
+ (Err(err), _) | (_, Err(err)) => Err(err),
+ }
+ }
+ b'{' => {
+ self.remaining_depth -= 1;
+ if self.remaining_depth == 0 {
+ return Err(self.peek_error(ErrorCode::RecursionLimitExceeded));
+ }
+
+ self.eat_char();
+ let ret = visitor.visit_map(MapAccess::new(self));
+
+ self.remaining_depth += 1;
+
+ match (ret, self.end_map()) {
+ (Ok(ret), Ok(())) => Ok(ret),
+ (Err(err), _) | (_, Err(err)) => Err(err),
+ }
+ }
+ _ => Err(self.peek_error(ErrorCode::ExpectedSomeValue)),
+ };
+
+ match value {
+ Ok(value) => Ok(value),
+ // The de::Error impl creates errors with unknown line and column.
+ // Fill in the position here by looking at the current index in the
+ // input. There is no way to tell whether this should call `error`
+ // or `peek_error` so pick the one that seems correct more often.
+ // Worst case, the position is off by one character.
+ Err(err) => Err(self.fix_position(err)),
+ }
+ }
+
+ fn deserialize_bool<V>(self, visitor: V) -> Result<V::Value>
+ where
+ V: de::Visitor<'de>,
+ {
+ let peek = match try!(self.parse_whitespace()) {
+ Some(b) => b,
+ None => {
+ return Err(self.peek_error(ErrorCode::EofWhileParsingValue));
+ }
+ };
+
+ let value = match peek {
+ b't' => {
+ self.eat_char();
+ try!(self.parse_ident(b"rue"));
+ visitor.visit_bool(true)
+ }
+ b'f' => {
+ self.eat_char();
+ try!(self.parse_ident(b"alse"));
+ visitor.visit_bool(false)
+ }
+ _ => Err(self.peek_invalid_type(&visitor)),
+ };
+
+ match value {
+ Ok(value) => Ok(value),
+ Err(err) => Err(self.fix_position(err)),
+ }
+ }
+
+ deserialize_prim_number!(deserialize_i8);
+ deserialize_prim_number!(deserialize_i16);
+ deserialize_prim_number!(deserialize_i32);
+ deserialize_prim_number!(deserialize_i64);
+ deserialize_prim_number!(deserialize_u8);
+ deserialize_prim_number!(deserialize_u16);
+ deserialize_prim_number!(deserialize_u32);
+ deserialize_prim_number!(deserialize_u64);
+ deserialize_prim_number!(deserialize_f32);
+ deserialize_prim_number!(deserialize_f64);
+
+ serde_if_integer128! {
+ fn deserialize_i128<V>(self, visitor: V) -> Result<V::Value>
+ where
+ V: de::Visitor<'de>,
+ {
+ let mut buf = String::new();
+
+ match try!(self.parse_whitespace()) {
+ Some(b'-') => {
+ self.eat_char();
+ buf.push('-');
+ }
+ Some(_) => {}
+ None => {
+ return Err(self.peek_error(ErrorCode::EofWhileParsingValue));
+ }
+ };
+
+ try!(self.scan_integer128(&mut buf));
+
+ let value = match buf.parse() {
+ Ok(int) => visitor.visit_i128(int),
+ Err(_) => {
+ return Err(self.error(ErrorCode::NumberOutOfRange));
+ }
+ };
+
+ match value {
+ Ok(value) => Ok(value),
+ Err(err) => Err(self.fix_position(err)),
+ }
+ }
+
+ fn deserialize_u128<V>(self, visitor: V) -> Result<V::Value>
+ where
+ V: de::Visitor<'de>,
+ {
+ match try!(self.parse_whitespace()) {
+ Some(b'-') => {
+ return Err(self.peek_error(ErrorCode::NumberOutOfRange));
+ }
+ Some(_) => {}
+ None => {
+ return Err(self.peek_error(ErrorCode::EofWhileParsingValue));
+ }
+ }
+
+ let mut buf = String::new();
+ try!(self.scan_integer128(&mut buf));
+
+ let value = match buf.parse() {
+ Ok(int) => visitor.visit_u128(int),
+ Err(_) => {
+ return Err(self.error(ErrorCode::NumberOutOfRange));
+ }
+ };
+
+ match value {
+ Ok(value) => Ok(value),
+ Err(err) => Err(self.fix_position(err)),
+ }
+ }
+ }
+
+ fn deserialize_char<V>(self, visitor: V) -> Result<V::Value>
+ where
+ V: de::Visitor<'de>,
+ {
+ self.deserialize_str(visitor)
+ }
+
+ fn deserialize_str<V>(self, visitor: V) -> Result<V::Value>
+ where
+ V: de::Visitor<'de>,
+ {
+ let peek = match try!(self.parse_whitespace()) {
+ Some(b) => b,
+ None => {
+ return Err(self.peek_error(ErrorCode::EofWhileParsingValue));
+ }
+ };
+
+ let value = match peek {
+ b'"' => {
+ self.eat_char();
+ self.str_buf.clear();
+ match try!(self.read.parse_str(&mut self.str_buf)) {
+ Reference::Borrowed(s) => visitor.visit_borrowed_str(s),
+ Reference::Copied(s) => visitor.visit_str(s),
+ }
+ }
+ _ => Err(self.peek_invalid_type(&visitor)),
+ };
+
+ match value {
+ Ok(value) => Ok(value),
+ Err(err) => Err(self.fix_position(err)),
+ }
+ }
+
+ fn deserialize_string<V>(self, visitor: V) -> Result<V::Value>
+ where
+ V: de::Visitor<'de>,
+ {
+ self.deserialize_str(visitor)
+ }
+
+ /// Parses a JSON string as bytes. Note that this function does not check
+ /// whether the bytes represent a valid UTF-8 string.
+ ///
+ /// The relevant part of the JSON specification is Section 8.2 of [RFC
+ /// 7159]:
+ ///
+ /// > When all the strings represented in a JSON text are composed entirely
+ /// > of Unicode characters (however escaped), then that JSON text is
+ /// > interoperable in the sense that all software implementations that
+ /// > parse it will agree on the contents of names and of string values in
+ /// > objects and arrays.
+ /// >
+ /// > However, the ABNF in this specification allows member names and string
+ /// > values to contain bit sequences that cannot encode Unicode characters;
+ /// > for example, "\uDEAD" (a single unpaired UTF-16 surrogate). Instances
+ /// > of this have been observed, for example, when a library truncates a
+ /// > UTF-16 string without checking whether the truncation split a
+ /// > surrogate pair. The behavior of software that receives JSON texts
+ /// > containing such values is unpredictable; for example, implementations
+ /// > might return different values for the length of a string value or even
+ /// > suffer fatal runtime exceptions.
+ ///
+ /// [RFC 7159]: https://tools.ietf.org/html/rfc7159
+ ///
+ /// The behavior of serde_json is specified to fail on non-UTF-8 strings
+ /// when deserializing into Rust UTF-8 string types such as String, and
+ /// succeed with non-UTF-8 bytes when deserializing using this method.
+ ///
+ /// Escape sequences are processed as usual, and for `\uXXXX` escapes it is
+ /// still checked if the hex number represents a valid Unicode code point.
+ ///
+ /// # Examples
+ ///
+ /// You can use this to parse JSON strings containing invalid UTF-8 bytes.
+ ///
+ /// ```rust
+ /// extern crate serde_json;
+ /// extern crate serde_bytes;
+ ///
+ /// use serde_bytes::ByteBuf;
+ ///
+ /// fn look_at_bytes() -> Result<(), serde_json::Error> {
+ /// let json_data = b"\"some bytes: \xe5\x00\xe5\"";
+ /// let bytes: ByteBuf = serde_json::from_slice(json_data)?;
+ ///
+ /// assert_eq!(b'\xe5', bytes[12]);
+ /// assert_eq!(b'\0', bytes[13]);
+ /// assert_eq!(b'\xe5', bytes[14]);
+ ///
+ /// Ok(())
+ /// }
+ /// #
+ /// # fn main() {
+ /// # look_at_bytes().unwrap();
+ /// # }
+ /// ```
+ ///
+ /// Backslash escape sequences like `\n` are still interpreted and required
+ /// to be valid, and `\u` escape sequences are required to represent valid
+ /// Unicode code points.
+ ///
+ /// ```rust
+ /// extern crate serde_json;
+ /// extern crate serde_bytes;
+ ///
+ /// use serde_bytes::ByteBuf;
+ ///
+ /// fn look_at_bytes() {
+ /// let json_data = b"\"invalid unicode surrogate: \\uD801\"";
+ /// let parsed: Result<ByteBuf, _> = serde_json::from_slice(json_data);
+ ///
+ /// assert!(parsed.is_err());
+ ///
+ /// let expected_msg = "unexpected end of hex escape at line 1 column 35";
+ /// assert_eq!(expected_msg, parsed.unwrap_err().to_string());
+ /// }
+ /// #
+ /// # fn main() {
+ /// # look_at_bytes();
+ /// # }
+ /// ```
+ fn deserialize_bytes<V>(self, visitor: V) -> Result<V::Value>
+ where
+ V: de::Visitor<'de>,
+ {
+ let peek = match try!(self.parse_whitespace()) {
+ Some(b) => b,
+ None => {
+ return Err(self.peek_error(ErrorCode::EofWhileParsingValue));
+ }
+ };
+
+ let value = match peek {
+ b'"' => {
+ self.eat_char();
+ self.str_buf.clear();
+ match try!(self.read.parse_str_raw(&mut self.str_buf)) {
+ Reference::Borrowed(b) => visitor.visit_borrowed_bytes(b),
+ Reference::Copied(b) => visitor.visit_bytes(b),
+ }
+ }
+ b'[' => self.deserialize_seq(visitor),
+ _ => Err(self.peek_invalid_type(&visitor)),
+ };
+
+ match value {
+ Ok(value) => Ok(value),
+ Err(err) => Err(self.fix_position(err)),
+ }
+ }
+
+ #[inline]
+ fn deserialize_byte_buf<V>(self, visitor: V) -> Result<V::Value>
+ where
+ V: de::Visitor<'de>,
+ {
+ self.deserialize_bytes(visitor)
+ }
+
+ /// Parses a `null` as a None, and any other values as a `Some(...)`.
+ #[inline]
+ fn deserialize_option<V>(self, visitor: V) -> Result<V::Value>
+ where
+ V: de::Visitor<'de>,
+ {
+ match try!(self.parse_whitespace()) {
+ Some(b'n') => {
+ self.eat_char();
+ try!(self.parse_ident(b"ull"));
+ visitor.visit_none()
+ }
+ _ => visitor.visit_some(self),
+ }
+ }
+
+ fn deserialize_unit<V>(self, visitor: V) -> Result<V::Value>
+ where
+ V: de::Visitor<'de>,
+ {
+ let peek = match try!(self.parse_whitespace()) {
+ Some(b) => b,
+ None => {
+ return Err(self.peek_error(ErrorCode::EofWhileParsingValue));
+ }
+ };
+
+ let value = match peek {
+ b'n' => {
+ self.eat_char();
+ try!(self.parse_ident(b"ull"));
+ visitor.visit_unit()
+ }
+ _ => Err(self.peek_invalid_type(&visitor)),
+ };
+
+ match value {
+ Ok(value) => Ok(value),
+ Err(err) => Err(self.fix_position(err)),
+ }
+ }
+
+ fn deserialize_unit_struct<V>(self, _name: &'static str, visitor: V) -> Result<V::Value>
+ where
+ V: de::Visitor<'de>,
+ {
+ self.deserialize_unit(visitor)
+ }
+
+ /// Parses a newtype struct as the underlying value.
+ #[inline]
+ fn deserialize_newtype_struct<V>(self, _name: &str, visitor: V) -> Result<V::Value>
+ where
+ V: de::Visitor<'de>,
+ {
+ visitor.visit_newtype_struct(self)
+ }
+
+ fn deserialize_seq<V>(self, visitor: V) -> Result<V::Value>
+ where
+ V: de::Visitor<'de>,
+ {
+ let peek = match try!(self.parse_whitespace()) {
+ Some(b) => b,
+ None => {
+ return Err(self.peek_error(ErrorCode::EofWhileParsingValue));
+ }
+ };
+
+ let value = match peek {
+ b'[' => {
+ self.remaining_depth -= 1;
+ if self.remaining_depth == 0 {
+ return Err(self.peek_error(ErrorCode::RecursionLimitExceeded));
+ }
+
+ self.eat_char();
+ let ret = visitor.visit_seq(SeqAccess::new(self));
+
+ self.remaining_depth += 1;
+
+ match (ret, self.end_seq()) {
+ (Ok(ret), Ok(())) => Ok(ret),
+ (Err(err), _) | (_, Err(err)) => Err(err),
+ }
+ }
+ _ => Err(self.peek_invalid_type(&visitor)),
+ };
+
+ match value {
+ Ok(value) => Ok(value),
+ Err(err) => Err(self.fix_position(err)),
+ }
+ }
+
+ fn deserialize_tuple<V>(self, _len: usize, visitor: V) -> Result<V::Value>
+ where
+ V: de::Visitor<'de>,
+ {
+ self.deserialize_seq(visitor)
+ }
+
+ fn deserialize_tuple_struct<V>(
+ self,
+ _name: &'static str,
+ _len: usize,
+ visitor: V,
+ ) -> Result<V::Value>
+ where
+ V: de::Visitor<'de>,
+ {
+ self.deserialize_seq(visitor)
+ }
+
+ fn deserialize_map<V>(self, visitor: V) -> Result<V::Value>
+ where
+ V: de::Visitor<'de>,
+ {
+ let peek = match try!(self.parse_whitespace()) {
+ Some(b) => b,
+ None => {
+ return Err(self.peek_error(ErrorCode::EofWhileParsingValue));
+ }
+ };
+
+ let value = match peek {
+ b'{' => {
+ self.remaining_depth -= 1;
+ if self.remaining_depth == 0 {
+ return Err(self.peek_error(ErrorCode::RecursionLimitExceeded));
+ }
+
+ self.eat_char();
+ let ret = visitor.visit_map(MapAccess::new(self));
+
+ self.remaining_depth += 1;
+
+ match (ret, self.end_map()) {
+ (Ok(ret), Ok(())) => Ok(ret),
+ (Err(err), _) | (_, Err(err)) => Err(err),
+ }
+ }
+ _ => Err(self.peek_invalid_type(&visitor)),
+ };
+
+ match value {
+ Ok(value) => Ok(value),
+ Err(err) => Err(self.fix_position(err)),
+ }
+ }
+
+ fn deserialize_struct<V>(
+ self,
+ _name: &'static str,
+ _fields: &'static [&'static str],
+ visitor: V,
+ ) -> Result<V::Value>
+ where
+ V: de::Visitor<'de>,
+ {
+ let peek = match try!(self.parse_whitespace()) {
+ Some(b) => b,
+ None => {
+ return Err(self.peek_error(ErrorCode::EofWhileParsingValue));
+ }
+ };
+
+ let value = match peek {
+ b'[' => {
+ self.remaining_depth -= 1;
+ if self.remaining_depth == 0 {
+ return Err(self.peek_error(ErrorCode::RecursionLimitExceeded));
+ }
+
+ self.eat_char();
+ let ret = visitor.visit_seq(SeqAccess::new(self));
+
+ self.remaining_depth += 1;
+
+ match (ret, self.end_seq()) {
+ (Ok(ret), Ok(())) => Ok(ret),
+ (Err(err), _) | (_, Err(err)) => Err(err),
+ }
+ }
+ b'{' => {
+ self.remaining_depth -= 1;
+ if self.remaining_depth == 0 {
+ return Err(self.peek_error(ErrorCode::RecursionLimitExceeded));
+ }
+
+ self.eat_char();
+ let ret = visitor.visit_map(MapAccess::new(self));
+
+ self.remaining_depth += 1;
+
+ match (ret, self.end_map()) {
+ (Ok(ret), Ok(())) => Ok(ret),
+ (Err(err), _) | (_, Err(err)) => Err(err),
+ }
+ }
+ _ => Err(self.peek_invalid_type(&visitor)),
+ };
+
+ match value {
+ Ok(value) => Ok(value),
+ Err(err) => Err(self.fix_position(err)),
+ }
+ }
+
+ /// Parses an enum as an object like `{"$KEY":$VALUE}`, where $VALUE is either a straight
+ /// value, a `[..]`, or a `{..}`.
+ #[inline]
+ fn deserialize_enum<V>(
+ self,
+ _name: &str,
+ _variants: &'static [&'static str],
+ visitor: V,
+ ) -> Result<V::Value>
+ where
+ V: de::Visitor<'de>,
+ {
+ match try!(self.parse_whitespace()) {
+ Some(b'{') => {
+ self.remaining_depth -= 1;
+ if self.remaining_depth == 0 {
+ return Err(self.peek_error(ErrorCode::RecursionLimitExceeded));
+ }
+
+ self.eat_char();
+ let value = try!(visitor.visit_enum(VariantAccess::new(self)));
+
+ self.remaining_depth += 1;
+
+ match try!(self.parse_whitespace()) {
+ Some(b'}') => {
+ self.eat_char();
+ Ok(value)
+ }
+ Some(_) => Err(self.error(ErrorCode::ExpectedSomeValue)),
+ None => Err(self.error(ErrorCode::EofWhileParsingObject)),
+ }
+ }
+ Some(b'"') => visitor.visit_enum(UnitVariantAccess::new(self)),
+ Some(_) => Err(self.peek_error(ErrorCode::ExpectedSomeValue)),
+ None => Err(self.peek_error(ErrorCode::EofWhileParsingValue)),
+ }
+ }
+
+ fn deserialize_identifier<V>(self, visitor: V) -> Result<V::Value>
+ where
+ V: de::Visitor<'de>,
+ {
+ self.deserialize_str(visitor)
+ }
+
+ fn deserialize_ignored_any<V>(self, visitor: V) -> Result<V::Value>
+ where
+ V: de::Visitor<'de>,
+ {
+ try!(self.ignore_value());
+ visitor.visit_unit()
+ }
+}
+
+struct SeqAccess<'a, R: 'a> {
+ de: &'a mut Deserializer<R>,
+ first: bool,
+}
+
+impl<'a, R: 'a> SeqAccess<'a, R> {
+ fn new(de: &'a mut Deserializer<R>) -> Self {
+ SeqAccess {
+ de: de,
+ first: true,
+ }
+ }
+}
+
+impl<'de, 'a, R: Read<'de> + 'a> de::SeqAccess<'de> for SeqAccess<'a, R> {
+ type Error = Error;
+
+ fn next_element_seed<T>(&mut self, seed: T) -> Result<Option<T::Value>>
+ where
+ T: de::DeserializeSeed<'de>,
+ {
+ let peek = match try!(self.de.parse_whitespace()) {
+ Some(b']') => {
+ return Ok(None);
+ }
+ Some(b',') if !self.first => {
+ self.de.eat_char();
+ try!(self.de.parse_whitespace())
+ }
+ Some(b) => {
+ if self.first {
+ self.first = false;
+ Some(b)
+ } else {
+ return Err(self.de.peek_error(ErrorCode::ExpectedListCommaOrEnd));
+ }
+ }
+ None => {
+ return Err(self.de.peek_error(ErrorCode::EofWhileParsingList));
+ }
+ };
+
+ match peek {
+ Some(b']') => Err(self.de.peek_error(ErrorCode::TrailingComma)),
+ Some(_) => Ok(Some(try!(seed.deserialize(&mut *self.de)))),
+ None => Err(self.de.peek_error(ErrorCode::EofWhileParsingValue)),
+ }
+ }
+}
+
+struct MapAccess<'a, R: 'a> {
+ de: &'a mut Deserializer<R>,
+ first: bool,
+}
+
+impl<'a, R: 'a> MapAccess<'a, R> {
+ fn new(de: &'a mut Deserializer<R>) -> Self {
+ MapAccess {
+ de: de,
+ first: true,
+ }
+ }
+}
+
+impl<'de, 'a, R: Read<'de> + 'a> de::MapAccess<'de> for MapAccess<'a, R> {
+ type Error = Error;
+
+ fn next_key_seed<K>(&mut self, seed: K) -> Result<Option<K::Value>>
+ where
+ K: de::DeserializeSeed<'de>,
+ {
+ let peek = match try!(self.de.parse_whitespace()) {
+ Some(b'}') => {
+ return Ok(None);
+ }
+ Some(b',') if !self.first => {
+ self.de.eat_char();
+ try!(self.de.parse_whitespace())
+ }
+ Some(b) => {
+ if self.first {
+ self.first = false;
+ Some(b)
+ } else {
+ return Err(self.de.peek_error(ErrorCode::ExpectedObjectCommaOrEnd));
+ }
+ }
+ None => {
+ return Err(self.de.peek_error(ErrorCode::EofWhileParsingObject));
+ }
+ };
+
+ match peek {
+ Some(b'"') => seed.deserialize(MapKey { de: &mut *self.de }).map(Some),
+ Some(b'}') => Err(self.de.peek_error(ErrorCode::TrailingComma)),
+ Some(_) => Err(self.de.peek_error(ErrorCode::KeyMustBeAString)),
+ None => Err(self.de.peek_error(ErrorCode::EofWhileParsingValue)),
+ }
+ }
+
+ fn next_value_seed<V>(&mut self, seed: V) -> Result<V::Value>
+ where
+ V: de::DeserializeSeed<'de>,
+ {
+ try!(self.de.parse_object_colon());
+
+ seed.deserialize(&mut *self.de)
+ }
+}
+
+struct VariantAccess<'a, R: 'a> {
+ de: &'a mut Deserializer<R>,
+}
+
+impl<'a, R: 'a> VariantAccess<'a, R> {
+ fn new(de: &'a mut Deserializer<R>) -> Self {
+ VariantAccess { de: de }
+ }
+}
+
+impl<'de, 'a, R: Read<'de> + 'a> de::EnumAccess<'de> for VariantAccess<'a, R> {
+ type Error = Error;
+ type Variant = Self;
+
+ fn variant_seed<V>(self, seed: V) -> Result<(V::Value, Self)>
+ where
+ V: de::DeserializeSeed<'de>,
+ {
+ let val = try!(seed.deserialize(&mut *self.de));
+ try!(self.de.parse_object_colon());
+ Ok((val, self))
+ }
+}
+
+impl<'de, 'a, R: Read<'de> + 'a> de::VariantAccess<'de> for VariantAccess<'a, R> {
+ type Error = Error;
+
+ fn unit_variant(self) -> Result<()> {
+ de::Deserialize::deserialize(self.de)
+ }
+
+ fn newtype_variant_seed<T>(self, seed: T) -> Result<T::Value>
+ where
+ T: de::DeserializeSeed<'de>,
+ {
+ seed.deserialize(self.de)
+ }
+
+ fn tuple_variant<V>(self, _len: usize, visitor: V) -> Result<V::Value>
+ where
+ V: de::Visitor<'de>,
+ {
+ de::Deserializer::deserialize_seq(self.de, visitor)
+ }
+
+ fn struct_variant<V>(self, fields: &'static [&'static str], visitor: V) -> Result<V::Value>
+ where
+ V: de::Visitor<'de>,
+ {
+ de::Deserializer::deserialize_struct(self.de, "", fields, visitor)
+ }
+}
+
+struct UnitVariantAccess<'a, R: 'a> {
+ de: &'a mut Deserializer<R>,
+}
+
+impl<'a, R: 'a> UnitVariantAccess<'a, R> {
+ fn new(de: &'a mut Deserializer<R>) -> Self {
+ UnitVariantAccess { de: de }
+ }
+}
+
+impl<'de, 'a, R: Read<'de> + 'a> de::EnumAccess<'de> for UnitVariantAccess<'a, R> {
+ type Error = Error;
+ type Variant = Self;
+
+ fn variant_seed<V>(self, seed: V) -> Result<(V::Value, Self)>
+ where
+ V: de::DeserializeSeed<'de>,
+ {
+ let variant = try!(seed.deserialize(&mut *self.de));
+ Ok((variant, self))
+ }
+}
+
+impl<'de, 'a, R: Read<'de> + 'a> de::VariantAccess<'de> for UnitVariantAccess<'a, R> {
+ type Error = Error;
+
+ fn unit_variant(self) -> Result<()> {
+ Ok(())
+ }
+
+ fn newtype_variant_seed<T>(self, _seed: T) -> Result<T::Value>
+ where
+ T: de::DeserializeSeed<'de>,
+ {
+ Err(de::Error::invalid_type(
+ Unexpected::UnitVariant,
+ &"newtype variant",
+ ))
+ }
+
+ fn tuple_variant<V>(self, _len: usize, _visitor: V) -> Result<V::Value>
+ where
+ V: de::Visitor<'de>,
+ {
+ Err(de::Error::invalid_type(
+ Unexpected::UnitVariant,
+ &"tuple variant",
+ ))
+ }
+
+ fn struct_variant<V>(self, _fields: &'static [&'static str], _visitor: V) -> Result<V::Value>
+ where
+ V: de::Visitor<'de>,
+ {
+ Err(de::Error::invalid_type(
+ Unexpected::UnitVariant,
+ &"struct variant",
+ ))
+ }
+}
+
+/// Only deserialize from this after peeking a '"' byte! Otherwise it may
+/// deserialize invalid JSON successfully.
+struct MapKey<'a, R: 'a> {
+ de: &'a mut Deserializer<R>,
+}
+
+macro_rules! deserialize_integer_key {
+ ($method:ident => $visit:ident) => {
+ fn $method<V>(self, visitor: V) -> Result<V::Value>
+ where
+ V: de::Visitor<'de>,
+ {
+ self.de.eat_char();
+ self.de.str_buf.clear();
+ let string = try!(self.de.read.parse_str(&mut self.de.str_buf));
+ match (string.parse(), string) {
+ (Ok(integer), _) => visitor.$visit(integer),
+ (Err(_), Reference::Borrowed(s)) => visitor.visit_borrowed_str(s),
+ (Err(_), Reference::Copied(s)) => visitor.visit_str(s),
+ }
+ }
+ }
+}
+
+impl<'de, 'a, R> de::Deserializer<'de> for MapKey<'a, R>
+where
+ R: Read<'de>,
+{
+ type Error = Error;
+
+ #[inline]
+ fn deserialize_any<V>(self, visitor: V) -> Result<V::Value>
+ where
+ V: de::Visitor<'de>,
+ {
+ self.de.eat_char();
+ self.de.str_buf.clear();
+ match try!(self.de.read.parse_str(&mut self.de.str_buf)) {
+ Reference::Borrowed(s) => visitor.visit_borrowed_str(s),
+ Reference::Copied(s) => visitor.visit_str(s),
+ }
+ }
+
+ deserialize_integer_key!(deserialize_i8 => visit_i8);
+ deserialize_integer_key!(deserialize_i16 => visit_i16);
+ deserialize_integer_key!(deserialize_i32 => visit_i32);
+ deserialize_integer_key!(deserialize_i64 => visit_i64);
+ deserialize_integer_key!(deserialize_u8 => visit_u8);
+ deserialize_integer_key!(deserialize_u16 => visit_u16);
+ deserialize_integer_key!(deserialize_u32 => visit_u32);
+ deserialize_integer_key!(deserialize_u64 => visit_u64);
+
+ serde_if_integer128! {
+ deserialize_integer_key!(deserialize_i128 => visit_i128);
+ deserialize_integer_key!(deserialize_u128 => visit_u128);
+ }
+
+ #[inline]
+ fn deserialize_option<V>(self, visitor: V) -> Result<V::Value>
+ where
+ V: de::Visitor<'de>,
+ {
+ // Map keys cannot be null.
+ visitor.visit_some(self)
+ }
+
+ #[inline]
+ fn deserialize_newtype_struct<V>(self, _name: &'static str, visitor: V) -> Result<V::Value>
+ where
+ V: de::Visitor<'de>,
+ {
+ visitor.visit_newtype_struct(self)
+ }
+
+ #[inline]
+ fn deserialize_enum<V>(
+ self,
+ name: &'static str,
+ variants: &'static [&'static str],
+ visitor: V,
+ ) -> Result<V::Value>
+ where
+ V: de::Visitor<'de>,
+ {
+ self.de.deserialize_enum(name, variants, visitor)
+ }
+
+ #[inline]
+ fn deserialize_bytes<V>(self, visitor: V) -> Result<V::Value>
+ where
+ V: de::Visitor<'de>,
+ {
+ self.de.deserialize_bytes(visitor)
+ }
+
+ #[inline]
+ fn deserialize_byte_buf<V>(self, visitor: V) -> Result<V::Value>
+ where
+ V: de::Visitor<'de>,
+ {
+ self.de.deserialize_bytes(visitor)
+ }
+
+ forward_to_deserialize_any! {
+ bool f32 f64 char str string unit unit_struct seq tuple tuple_struct map
+ struct identifier ignored_any
+ }
+}
+
+//////////////////////////////////////////////////////////////////////////////
+
+/// Iterator that deserializes a stream into multiple JSON values.
+///
+/// A stream deserializer can be created from any JSON deserializer using the
+/// `Deserializer::into_iter` method.
+///
+/// The data can consist of any JSON value. Values need to be a self-delineating value e.g.
+/// arrays, objects, or strings, or be followed by whitespace or a self-delineating value.
+///
+/// ```rust
+/// extern crate serde_json;
+///
+/// use serde_json::{Deserializer, Value};
+///
+/// fn main() {
+/// let data = "{\"k\": 3}1\"cool\"\"stuff\" 3{} [0, 1, 2]";
+///
+/// let stream = Deserializer::from_str(data).into_iter::<Value>();
+///
+/// for value in stream {
+/// println!("{}", value.unwrap());
+/// }
+/// }
+/// ```
+pub struct StreamDeserializer<'de, R, T> {
+ de: Deserializer<R>,
+ offset: usize,
+ output: PhantomData<T>,
+ lifetime: PhantomData<&'de ()>,
+}
+
+impl<'de, R, T> StreamDeserializer<'de, R, T>
+where
+ R: read::Read<'de>,
+ T: de::Deserialize<'de>,
+{
+ /// Create a JSON stream deserializer from one of the possible serde_json
+ /// input sources.
+ ///
+ /// Typically it is more convenient to use one of these methods instead:
+ ///
+ /// - Deserializer::from_str(...).into_iter()
+ /// - Deserializer::from_bytes(...).into_iter()
+ /// - Deserializer::from_reader(...).into_iter()
+ pub fn new(read: R) -> Self {
+ let offset = read.byte_offset();
+ StreamDeserializer {
+ de: Deserializer::new(read),
+ offset: offset,
+ output: PhantomData,
+ lifetime: PhantomData,
+ }
+ }
+
+ /// Returns the number of bytes so far deserialized into a successful `T`.
+ ///
+ /// If a stream deserializer returns an EOF error, new data can be joined to
+ /// `old_data[stream.byte_offset()..]` to try again.
+ ///
+ /// ```rust
+ /// let data = b"[0] [1] [";
+ ///
+ /// let de = serde_json::Deserializer::from_slice(data);
+ /// let mut stream = de.into_iter::<Vec<i32>>();
+ /// assert_eq!(0, stream.byte_offset());
+ ///
+ /// println!("{:?}", stream.next()); // [0]
+ /// assert_eq!(3, stream.byte_offset());
+ ///
+ /// println!("{:?}", stream.next()); // [1]
+ /// assert_eq!(7, stream.byte_offset());
+ ///
+ /// println!("{:?}", stream.next()); // error
+ /// assert_eq!(8, stream.byte_offset());
+ ///
+ /// // If err.is_eof(), can join the remaining data to new data and continue.
+ /// let remaining = &data[stream.byte_offset()..];
+ /// ```
+ ///
+ /// *Note:* In the future this method may be changed to return the number of
+ /// bytes so far deserialized into a successful T *or* syntactically valid
+ /// JSON skipped over due to a type error. See [serde-rs/json#70] for an
+ /// example illustrating this.
+ ///
+ /// [serde-rs/json#70]: https://github.com/serde-rs/json/issues/70
+ pub fn byte_offset(&self) -> usize {
+ self.offset
+ }
+
+ fn peek_end_of_value(&mut self) -> Result<()> {
+ match try!(self.de.peek()) {
+ Some(b' ') | Some(b'\n') | Some(b'\t') | Some(b'\r') | Some(b'"') | Some(b'[')
+ | Some(b']') | Some(b'{') | Some(b'}') | Some(b',') | Some(b':') | None => Ok(()),
+ Some(_) => {
+ let position = self.de.read.peek_position();
+ Err(Error::syntax(
+ ErrorCode::TrailingCharacters,
+ position.line,
+ position.column,
+ ))
+ }
+ }
+ }
+}
+
+impl<'de, R, T> Iterator for StreamDeserializer<'de, R, T>
+where
+ R: Read<'de>,
+ T: de::Deserialize<'de>,
+{
+ type Item = Result<T>;
+
+ fn next(&mut self) -> Option<Result<T>> {
+ // skip whitespaces, if any
+ // this helps with trailing whitespaces, since whitespaces between
+ // values are handled for us.
+ match self.de.parse_whitespace() {
+ Ok(None) => {
+ self.offset = self.de.read.byte_offset();
+ None
+ }
+ Ok(Some(b)) => {
+ // If the value does not have a clear way to show the end of the value
+ // (like numbers, null, true etc.) we have to look for whitespace or
+ // the beginning of a self-delineated value.
+ let self_delineated_value = match b {
+ b'[' | b'"' | b'{' => true,
+ _ => false,
+ };
+ self.offset = self.de.read.byte_offset();
+ let result = de::Deserialize::deserialize(&mut self.de);
+
+ Some(match result {
+ Ok(value) => {
+ self.offset = self.de.read.byte_offset();
+ if self_delineated_value {
+ Ok(value)
+ } else {
+ self.peek_end_of_value().map(|_| value)
+ }
+ }
+ Err(e) => Err(e),
+ })
+ }
+ Err(e) => Some(Err(e)),
+ }
+ }
+}
+
+//////////////////////////////////////////////////////////////////////////////
+
+fn from_trait<'de, R, T>(read: R) -> Result<T>
+where
+ R: Read<'de>,
+ T: de::Deserialize<'de>,
+{
+ let mut de = Deserializer::new(read);
+ let value = try!(de::Deserialize::deserialize(&mut de));
+
+ // Make sure the whole stream has been consumed.
+ try!(de.end());
+ Ok(value)
+}
+
+/// Deserialize an instance of type `T` from an IO stream of JSON.
+///
+/// # Errors
+///
+/// This conversion can fail if the structure of the input does not match the
+/// structure expected by `T`, for example if `T` is a struct type but the input
+/// contains something other than a JSON map. It can also fail if the structure
+/// is correct but `T`'s implementation of `Deserialize` decides that something
+/// is wrong with the data, for example required struct fields are missing from
+/// the JSON map or some number is too big to fit in the expected primitive
+/// type.
+///
+/// ```rust
+/// #[macro_use]
+/// extern crate serde_derive;
+///
+/// extern crate serde;
+/// extern crate serde_json;
+///
+/// use std::error::Error;
+/// use std::fs::File;
+/// use std::path::Path;
+///
+/// #[derive(Deserialize, Debug)]
+/// struct User {
+/// fingerprint: String,
+/// location: String,
+/// }
+///
+/// fn read_user_from_file<P: AsRef<Path>>(path: P) -> Result<User, Box<Error>> {
+/// // Open the file in read-only mode.
+/// let file = File::open(path)?;
+///
+/// // Read the JSON contents of the file as an instance of `User`.
+/// let u = serde_json::from_reader(file)?;
+///
+/// // Return the `User`.
+/// Ok(u)
+/// }
+///
+/// fn main() {
+/// # }
+/// # fn fake_main() {
+/// let u = read_user_from_file("test.json").unwrap();
+/// println!("{:#?}", u);
+/// }
+/// ```
+pub fn from_reader<R, T>(rdr: R) -> Result<T>
+where
+ R: io::Read,
+ T: de::DeserializeOwned,
+{
+ from_trait(read::IoRead::new(rdr))
+}
+
+/// Deserialize an instance of type `T` from bytes of JSON text.
+///
+/// # Errors
+///
+/// This conversion can fail if the structure of the input does not match the
+/// structure expected by `T`, for example if `T` is a struct type but the input
+/// contains something other than a JSON map. It can also fail if the structure
+/// is correct but `T`'s implementation of `Deserialize` decides that something
+/// is wrong with the data, for example required struct fields are missing from
+/// the JSON map or some number is too big to fit in the expected primitive
+/// type.
+///
+/// ```rust
+/// #[macro_use]
+/// extern crate serde_derive;
+///
+/// extern crate serde;
+/// extern crate serde_json;
+///
+/// #[derive(Deserialize, Debug)]
+/// struct User {
+/// fingerprint: String,
+/// location: String,
+/// }
+///
+/// fn main() {
+/// // The type of `j` is `&[u8]`
+/// let j = b"{
+/// \"fingerprint\": \"0xF9BA143B95FF6D82\",
+/// \"location\": \"Menlo Park, CA\"
+/// }";
+///
+/// let u: User = serde_json::from_slice(j).unwrap();
+/// println!("{:#?}", u);
+/// }
+/// ```
+pub fn from_slice<'a, T>(v: &'a [u8]) -> Result<T>
+where
+ T: de::Deserialize<'a>,
+{
+ from_trait(read::SliceRead::new(v))
+}
+
+/// Deserialize an instance of type `T` from a string of JSON text.
+///
+/// # Errors
+///
+/// This conversion can fail if the structure of the input does not match the
+/// structure expected by `T`, for example if `T` is a struct type but the input
+/// contains something other than a JSON map. It can also fail if the structure
+/// is correct but `T`'s implementation of `Deserialize` decides that something
+/// is wrong with the data, for example required struct fields are missing from
+/// the JSON map or some number is too big to fit in the expected primitive
+/// type.
+///
+/// ```rust
+/// #[macro_use]
+/// extern crate serde_derive;
+///
+/// extern crate serde;
+/// extern crate serde_json;
+///
+/// #[derive(Deserialize, Debug)]
+/// struct User {
+/// fingerprint: String,
+/// location: String,
+/// }
+///
+/// fn main() {
+/// // The type of `j` is `&str`
+/// let j = "{
+/// \"fingerprint\": \"0xF9BA143B95FF6D82\",
+/// \"location\": \"Menlo Park, CA\"
+/// }";
+///
+/// let u: User = serde_json::from_str(j).unwrap();
+/// println!("{:#?}", u);
+/// }
+/// ```
+pub fn from_str<'a, T>(s: &'a str) -> Result<T>
+where
+ T: de::Deserialize<'a>,
+{
+ from_trait(read::StrRead::new(s))
+}
new file mode 100644
--- /dev/null
+++ b/third_party/rust/serde_json/src/error.rs
@@ -0,0 +1,429 @@
+// Copyright 2017 Serde Developers
+//
+// Licensed under the Apache License, Version 2.0 <LICENSE-APACHE or
+// http://www.apache.org/licenses/LICENSE-2.0> or the MIT license
+// <LICENSE-MIT or http://opensource.org/licenses/MIT>, at your
+// option. This file may not be copied, modified, or distributed
+// except according to those terms.
+
+//! When serializing or deserializing JSON goes wrong.
+
+use std::error;
+use std::fmt::{self, Debug, Display};
+use std::io;
+use std::result;
+
+use serde::de;
+use serde::ser;
+
+/// This type represents all possible errors that can occur when serializing or
+/// deserializing JSON data.
+pub struct Error {
+ /// This `Box` allows us to keep the size of `Error` as small as possible. A
+ /// larger `Error` type was substantially slower due to all the functions
+ /// that pass around `Result<T, Error>`.
+ err: Box<ErrorImpl>,
+}
+
+/// Alias for a `Result` with the error type `serde_json::Error`.
+pub type Result<T> = result::Result<T, Error>;
+
+impl Error {
+ /// One-based line number at which the error was detected.
+ ///
+ /// Characters in the first line of the input (before the first newline
+ /// character) are in line 1.
+ pub fn line(&self) -> usize {
+ self.err.line
+ }
+
+ /// One-based column number at which the error was detected.
+ ///
+ /// The first character in the input and any characters immediately
+ /// following a newline character are in column 1.
+ ///
+ /// Note that errors may occur in column 0, for example if a read from an IO
+ /// stream fails immediately following a previously read newline character.
+ pub fn column(&self) -> usize {
+ self.err.column
+ }
+
+ /// Categorizes the cause of this error.
+ ///
+ /// - `Category::Io` - failure to read or write bytes on an IO stream
+ /// - `Category::Syntax` - input that is not syntactically valid JSON
+ /// - `Category::Data` - input data that is semantically incorrect
+ /// - `Category::Eof` - unexpected end of the input data
+ pub fn classify(&self) -> Category {
+ match self.err.code {
+ ErrorCode::Message(_) => Category::Data,
+ ErrorCode::Io(_) => Category::Io,
+ ErrorCode::EofWhileParsingList
+ | ErrorCode::EofWhileParsingObject
+ | ErrorCode::EofWhileParsingString
+ | ErrorCode::EofWhileParsingValue => Category::Eof,
+ ErrorCode::ExpectedColon
+ | ErrorCode::ExpectedListCommaOrEnd
+ | ErrorCode::ExpectedObjectCommaOrEnd
+ | ErrorCode::ExpectedObjectOrArray
+ | ErrorCode::ExpectedSomeIdent
+ | ErrorCode::ExpectedSomeValue
+ | ErrorCode::ExpectedSomeString
+ | ErrorCode::InvalidEscape
+ | ErrorCode::InvalidNumber
+ | ErrorCode::NumberOutOfRange
+ | ErrorCode::InvalidUnicodeCodePoint
+ | ErrorCode::ControlCharacterWhileParsingString
+ | ErrorCode::KeyMustBeAString
+ | ErrorCode::LoneLeadingSurrogateInHexEscape
+ | ErrorCode::TrailingComma
+ | ErrorCode::TrailingCharacters
+ | ErrorCode::UnexpectedEndOfHexEscape
+ | ErrorCode::RecursionLimitExceeded => Category::Syntax,
+ }
+ }
+
+ /// Returns true if this error was caused by a failure to read or write
+ /// bytes on an IO stream.
+ pub fn is_io(&self) -> bool {
+ self.classify() == Category::Io
+ }
+
+ /// Returns true if this error was caused by input that was not
+ /// syntactically valid JSON.
+ pub fn is_syntax(&self) -> bool {
+ self.classify() == Category::Syntax
+ }
+
+ /// Returns true if this error was caused by input data that was
+ /// semantically incorrect.
+ ///
+ /// For example, JSON containing a number is semantically incorrect when the
+ /// type being deserialized into holds a String.
+ pub fn is_data(&self) -> bool {
+ self.classify() == Category::Data
+ }
+
+ /// Returns true if this error was caused by prematurely reaching the end of
+ /// the input data.
+ ///
+ /// Callers that process streaming input may be interested in retrying the
+ /// deserialization once more data is available.
+ pub fn is_eof(&self) -> bool {
+ self.classify() == Category::Eof
+ }
+}
+
+/// Categorizes the cause of a `serde_json::Error`.
+#[derive(Copy, Clone, PartialEq, Eq, Debug)]
+pub enum Category {
+ /// The error was caused by a failure to read or write bytes on an IO
+ /// stream.
+ Io,
+
+ /// The error was caused by input that was not syntactically valid JSON.
+ Syntax,
+
+ /// The error was caused by input data that was semantically incorrect.
+ ///
+ /// For example, JSON containing a number is semantically incorrect when the
+ /// type being deserialized into holds a String.
+ Data,
+
+ /// The error was caused by prematurely reaching the end of the input data.
+ ///
+ /// Callers that process streaming input may be interested in retrying the
+ /// deserialization once more data is available.
+ Eof,
+}
+
+#[cfg_attr(feature = "cargo-clippy", allow(fallible_impl_from))]
+impl From<Error> for io::Error {
+ /// Convert a `serde_json::Error` into an `io::Error`.
+ ///
+ /// JSON syntax and data errors are turned into `InvalidData` IO errors.
+ /// EOF errors are turned into `UnexpectedEof` IO errors.
+ ///
+ /// ```rust
+ /// use std::io;
+ ///
+ /// enum MyError {
+ /// Io(io::Error),
+ /// Json(serde_json::Error),
+ /// }
+ ///
+ /// impl From<serde_json::Error> for MyError {
+ /// fn from(err: serde_json::Error) -> MyError {
+ /// use serde_json::error::Category;
+ /// match err.classify() {
+ /// Category::Io => {
+ /// MyError::Io(err.into())
+ /// }
+ /// Category::Syntax | Category::Data | Category::Eof => {
+ /// MyError::Json(err)
+ /// }
+ /// }
+ /// }
+ /// }
+ /// ```
+ fn from(j: Error) -> Self {
+ if let ErrorCode::Io(err) = j.err.code {
+ err
+ } else {
+ match j.classify() {
+ Category::Io => unreachable!(),
+ Category::Syntax | Category::Data => io::Error::new(io::ErrorKind::InvalidData, j),
+ Category::Eof => io::Error::new(io::ErrorKind::UnexpectedEof, j),
+ }
+ }
+ }
+}
+
+struct ErrorImpl {
+ code: ErrorCode,
+ line: usize,
+ column: usize,
+}
+
+// Not public API. Should be pub(crate).
+#[doc(hidden)]
+pub enum ErrorCode {
+ /// Catchall for syntax error messages
+ Message(Box<str>),
+
+ /// Some IO error occurred while serializing or deserializing.
+ Io(io::Error),
+
+ /// EOF while parsing a list.
+ EofWhileParsingList,
+
+ /// EOF while parsing an object.
+ EofWhileParsingObject,
+
+ /// EOF while parsing a string.
+ EofWhileParsingString,
+
+ /// EOF while parsing a JSON value.
+ EofWhileParsingValue,
+
+ /// Expected this character to be a `':'`.
+ ExpectedColon,
+
+ /// Expected this character to be either a `','` or a `']'`.
+ ExpectedListCommaOrEnd,
+
+ /// Expected this character to be either a `','` or a `'}'`.
+ ExpectedObjectCommaOrEnd,
+
+ /// Expected this character to be either a `'{'` or a `'['`.
+ ExpectedObjectOrArray,
+
+ /// Expected to parse either a `true`, `false`, or a `null`.
+ ExpectedSomeIdent,
+
+ /// Expected this character to start a JSON value.
+ ExpectedSomeValue,
+
+ /// Expected this character to start a JSON string.
+ ExpectedSomeString,
+
+ /// Invalid hex escape code.
+ InvalidEscape,
+
+ /// Invalid number.
+ InvalidNumber,
+
+ /// Number is bigger than the maximum value of its type.
+ NumberOutOfRange,
+
+ /// Invalid unicode code point.
+ InvalidUnicodeCodePoint,
+
+ /// Control character found while parsing a string.
+ ControlCharacterWhileParsingString,
+
+ /// Object key is not a string.
+ KeyMustBeAString,
+
+ /// Lone leading surrogate in hex escape.
+ LoneLeadingSurrogateInHexEscape,
+
+ /// JSON has a comma after the last value in an array or map.
+ TrailingComma,
+
+ /// JSON has non-whitespace trailing characters after the value.
+ TrailingCharacters,
+
+ /// Unexpected end of hex excape.
+ UnexpectedEndOfHexEscape,
+
+ /// Encountered nesting of JSON maps and arrays more than 128 layers deep.
+ RecursionLimitExceeded,
+}
+
+impl Error {
+ // Not public API. Should be pub(crate).
+ #[doc(hidden)]
+ #[cold]
+ pub fn syntax(code: ErrorCode, line: usize, column: usize) -> Self {
+ Error {
+ err: Box::new(ErrorImpl {
+ code: code,
+ line: line,
+ column: column,
+ }),
+ }
+ }
+
+ // Not public API. Should be pub(crate).
+ //
+ // Update `eager_json` crate when this function changes.
+ #[doc(hidden)]
+ #[cold]
+ pub fn io(error: io::Error) -> Self {
+ Error {
+ err: Box::new(ErrorImpl {
+ code: ErrorCode::Io(error),
+ line: 0,
+ column: 0,
+ }),
+ }
+ }
+
+ // Not public API. Should be pub(crate).
+ #[doc(hidden)]
+ #[cold]
+ pub fn fix_position<F>(self, f: F) -> Self
+ where
+ F: FnOnce(ErrorCode) -> Error,
+ {
+ if self.err.line == 0 {
+ f(self.err.code)
+ } else {
+ self
+ }
+ }
+}
+
+impl Display for ErrorCode {
+ fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
+ match *self {
+ ErrorCode::Message(ref msg) => f.write_str(msg),
+ ErrorCode::Io(ref err) => Display::fmt(err, f),
+ ErrorCode::EofWhileParsingList => f.write_str("EOF while parsing a list"),
+ ErrorCode::EofWhileParsingObject => f.write_str("EOF while parsing an object"),
+ ErrorCode::EofWhileParsingString => f.write_str("EOF while parsing a string"),
+ ErrorCode::EofWhileParsingValue => f.write_str("EOF while parsing a value"),
+ ErrorCode::ExpectedColon => f.write_str("expected `:`"),
+ ErrorCode::ExpectedListCommaOrEnd => f.write_str("expected `,` or `]`"),
+ ErrorCode::ExpectedObjectCommaOrEnd => f.write_str("expected `,` or `}`"),
+ ErrorCode::ExpectedObjectOrArray => f.write_str("expected `{` or `[`"),
+ ErrorCode::ExpectedSomeIdent => f.write_str("expected ident"),
+ ErrorCode::ExpectedSomeValue => f.write_str("expected value"),
+ ErrorCode::ExpectedSomeString => f.write_str("expected string"),
+ ErrorCode::InvalidEscape => f.write_str("invalid escape"),
+ ErrorCode::InvalidNumber => f.write_str("invalid number"),
+ ErrorCode::NumberOutOfRange => f.write_str("number out of range"),
+ ErrorCode::InvalidUnicodeCodePoint => f.write_str("invalid unicode code point"),
+ ErrorCode::ControlCharacterWhileParsingString => {
+ f.write_str("control character (\\u0000-\\u001F) found while parsing a string")
+ }
+ ErrorCode::KeyMustBeAString => f.write_str("key must be a string"),
+ ErrorCode::LoneLeadingSurrogateInHexEscape => {
+ f.write_str("lone leading surrogate in hex escape")
+ }
+ ErrorCode::TrailingComma => f.write_str("trailing comma"),
+ ErrorCode::TrailingCharacters => f.write_str("trailing characters"),
+ ErrorCode::UnexpectedEndOfHexEscape => f.write_str("unexpected end of hex escape"),
+ ErrorCode::RecursionLimitExceeded => f.write_str("recursion limit exceeded"),
+ }
+ }
+}
+
+impl error::Error for Error {
+ fn description(&self) -> &str {
+ match self.err.code {
+ ErrorCode::Io(ref err) => error::Error::description(err),
+ _ => {
+ // If you want a better message, use Display::fmt or to_string().
+ "JSON error"
+ }
+ }
+ }
+
+ fn cause(&self) -> Option<&error::Error> {
+ match self.err.code {
+ ErrorCode::Io(ref err) => Some(err),
+ _ => None,
+ }
+ }
+}
+
+impl Display for Error {
+ fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
+ Display::fmt(&*self.err, f)
+ }
+}
+
+impl Display for ErrorImpl {
+ fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
+ if self.line == 0 {
+ Display::fmt(&self.code, f)
+ } else {
+ write!(
+ f,
+ "{} at line {} column {}",
+ self.code, self.line, self.column
+ )
+ }
+ }
+}
+
+// Remove two layers of verbosity from the debug representation. Humans often
+// end up seeing this representation because it is what unwrap() shows.
+impl Debug for Error {
+ fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
+ write!(
+ f,
+ "Error({:?}, line: {}, column: {})",
+ self.err.code.to_string(),
+ self.err.line,
+ self.err.column
+ )
+ }
+}
+
+impl de::Error for Error {
+ #[cold]
+ fn custom<T: Display>(msg: T) -> Error {
+ Error {
+ err: Box::new(ErrorImpl {
+ code: ErrorCode::Message(msg.to_string().into_boxed_str()),
+ line: 0,
+ column: 0,
+ }),
+ }
+ }
+
+ #[cold]
+ fn invalid_type(unexp: de::Unexpected, exp: &de::Expected) -> Self {
+ if let de::Unexpected::Unit = unexp {
+ Error::custom(format_args!("invalid type: null, expected {}", exp))
+ } else {
+ Error::custom(format_args!("invalid type: {}, expected {}", unexp, exp))
+ }
+ }
+}
+
+impl ser::Error for Error {
+ #[cold]
+ fn custom<T: Display>(msg: T) -> Error {
+ Error {
+ err: Box::new(ErrorImpl {
+ code: ErrorCode::Message(msg.to_string().into_boxed_str()),
+ line: 0,
+ column: 0,
+ }),
+ }
+ }
+}
new file mode 100644
--- /dev/null
+++ b/third_party/rust/serde_json/src/iter.rs
@@ -0,0 +1,78 @@
+// Copyright 2017 Serde Developers
+//
+// Licensed under the Apache License, Version 2.0 <LICENSE-APACHE or
+// http://www.apache.org/licenses/LICENSE-2.0> or the MIT license
+// <LICENSE-MIT or http://opensource.org/licenses/MIT>, at your
+// option. This file may not be copied, modified, or distributed
+// except according to those terms.
+
+use std::io;
+
+pub struct LineColIterator<I> {
+ iter: I,
+
+ /// Index of the current line. Characters in the first line of the input
+ /// (before the first newline character) are in line 1.
+ line: usize,
+
+ /// Index of the current column. The first character in the input and any
+ /// characters immediately following a newline character are in column 1.
+ /// The column is 0 immediately after a newline character has been read.
+ col: usize,
+
+ /// Byte offset of the start of the current line. This is the sum of lenghts
+ /// of all previous lines. Keeping track of things this way allows efficient
+ /// computation of the current line, column, and byte offset while only
+ /// updating one of the counters in `next()` in the common case.
+ start_of_line: usize,
+}
+
+impl<I> LineColIterator<I>
+where
+ I: Iterator<Item = io::Result<u8>>,
+{
+ pub fn new(iter: I) -> LineColIterator<I> {
+ LineColIterator {
+ iter: iter,
+ line: 1,
+ col: 0,
+ start_of_line: 0,
+ }
+ }
+
+ pub fn line(&self) -> usize {
+ self.line
+ }
+
+ pub fn col(&self) -> usize {
+ self.col
+ }
+
+ pub fn byte_offset(&self) -> usize {
+ self.start_of_line + self.col
+ }
+}
+
+impl<I> Iterator for LineColIterator<I>
+where
+ I: Iterator<Item = io::Result<u8>>,
+{
+ type Item = io::Result<u8>;
+
+ fn next(&mut self) -> Option<io::Result<u8>> {
+ match self.iter.next() {
+ None => None,
+ Some(Ok(b'\n')) => {
+ self.start_of_line += self.col + 1;
+ self.line += 1;
+ self.col = 0;
+ Some(Ok(b'\n'))
+ }
+ Some(Ok(c)) => {
+ self.col += 1;
+ Some(Ok(c))
+ }
+ Some(Err(e)) => Some(Err(e)),
+ }
+ }
+}
new file mode 100644
--- /dev/null
+++ b/third_party/rust/serde_json/src/lib.rs
@@ -0,0 +1,388 @@
+// Copyright 2017 Serde Developers
+//
+// Licensed under the Apache License, Version 2.0 <LICENSE-APACHE or
+// http://www.apache.org/licenses/LICENSE-2.0> or the MIT license
+// <LICENSE-MIT or http://opensource.org/licenses/MIT>, at your
+// option. This file may not be copied, modified, or distributed
+// except according to those terms.
+
+//! # Serde JSON
+//!
+//! JSON is a ubiquitous open-standard format that uses human-readable text to
+//! transmit data objects consisting of key-value pairs.
+//!
+//! ```json,ignore
+//! {
+//! "name": "John Doe",
+//! "age": 43,
+//! "address": {
+//! "street": "10 Downing Street",
+//! "city": "London"
+//! },
+//! "phones": [
+//! "+44 1234567",
+//! "+44 2345678"
+//! ]
+//! }
+//! ```
+//!
+//! There are three common ways that you might find yourself needing to work
+//! with JSON data in Rust.
+//!
+//! - **As text data.** An unprocessed string of JSON data that you receive on
+//! an HTTP endpoint, read from a file, or prepare to send to a remote
+//! server.
+//! - **As an untyped or loosely typed representation.** Maybe you want to
+//! check that some JSON data is valid before passing it on, but without
+//! knowing the structure of what it contains. Or you want to do very basic
+//! manipulations like insert a key in a particular spot.
+//! - **As a strongly typed Rust data structure.** When you expect all or most
+//! of your data to conform to a particular structure and want to get real
+//! work done without JSON's loosey-goosey nature tripping you up.
+//!
+//! Serde JSON provides efficient, flexible, safe ways of converting data
+//! between each of these representations.
+//!
+//! # Operating on untyped JSON values
+//!
+//! Any valid JSON data can be manipulated in the following recursive enum
+//! representation. This data structure is [`serde_json::Value`][value].
+//!
+//! ```rust
+//! # use serde_json::{Number, Map};
+//! #
+//! # #[allow(dead_code)]
+//! enum Value {
+//! Null,
+//! Bool(bool),
+//! Number(Number),
+//! String(String),
+//! Array(Vec<Value>),
+//! Object(Map<String, Value>),
+//! }
+//! ```
+//!
+//! A string of JSON data can be parsed into a `serde_json::Value` by the
+//! [`serde_json::from_str`][from_str] function. There is also
+//! [`from_slice`][from_slice] for parsing from a byte slice &[u8] and
+//! [`from_reader`][from_reader] for parsing from any `io::Read` like a File or
+//! a TCP stream.
+//!
+//! ```rust
+//! extern crate serde_json;
+//!
+//! use serde_json::{Value, Error};
+//!
+//! fn untyped_example() -> Result<(), Error> {
+//! // Some JSON input data as a &str. Maybe this comes from the user.
+//! let data = r#"{
+//! "name": "John Doe",
+//! "age": 43,
+//! "phones": [
+//! "+44 1234567",
+//! "+44 2345678"
+//! ]
+//! }"#;
+//!
+//! // Parse the string of data into serde_json::Value.
+//! let v: Value = serde_json::from_str(data)?;
+//!
+//! // Access parts of the data by indexing with square brackets.
+//! println!("Please call {} at the number {}", v["name"], v["phones"][0]);
+//!
+//! Ok(())
+//! }
+//! #
+//! # fn main() {
+//! # untyped_example().unwrap();
+//! # }
+//! ```
+//!
+//! The result of square bracket indexing like `v["name"]` is a borrow of the
+//! data at that index, so the type is `&Value`. A JSON map can be indexed with
+//! string keys, while a JSON array can be indexed with integer keys. If the
+//! type of the data is not right for the type with which it is being indexed,
+//! or if a map does not contain the key being indexed, or if the index into a
+//! vector is out of bounds, the returned element is `Value::Null`.
+//!
+//! When a `Value` is printed, it is printed as a JSON string. So in the code
+//! above, the output looks like `Please call "John Doe" at the number "+44
+//! 1234567"`. The quotation marks appear because `v["name"]` is a `&Value`
+//! containing a JSON string and its JSON representation is `"John Doe"`.
+//! Printing as a plain string without quotation marks involves converting from
+//! a JSON string to a Rust string with [`as_str()`] or avoiding the use of
+//! `Value` as described in the following section.
+//!
+//! [`as_str()`]: https://docs.serde.rs/serde_json/enum.Value.html#method.as_str
+//!
+//! The `Value` representation is sufficient for very basic tasks but can be
+//! tedious to work with for anything more significant. Error handling is
+//! verbose to implement correctly, for example imagine trying to detect the
+//! presence of unrecognized fields in the input data. The compiler is powerless
+//! to help you when you make a mistake, for example imagine typoing `v["name"]`
+//! as `v["nmae"]` in one of the dozens of places it is used in your code.
+//!
+//! # Parsing JSON as strongly typed data structures
+//!
+//! Serde provides a powerful way of mapping JSON data into Rust data structures
+//! largely automatically.
+//!
+//! ```rust
+//! extern crate serde;
+//! extern crate serde_json;
+//!
+//! #[macro_use]
+//! extern crate serde_derive;
+//!
+//! use serde_json::Error;
+//!
+//! #[derive(Serialize, Deserialize)]
+//! struct Person {
+//! name: String,
+//! age: u8,
+//! phones: Vec<String>,
+//! }
+//!
+//! fn typed_example() -> Result<(), Error> {
+//! // Some JSON input data as a &str. Maybe this comes from the user.
+//! let data = r#"{
+//! "name": "John Doe",
+//! "age": 43,
+//! "phones": [
+//! "+44 1234567",
+//! "+44 2345678"
+//! ]
+//! }"#;
+//!
+//! // Parse the string of data into a Person object. This is exactly the
+//! // same function as the one that produced serde_json::Value above, but
+//! // now we are asking it for a Person as output.
+//! let p: Person = serde_json::from_str(data)?;
+//!
+//! // Do things just like with any other Rust data structure.
+//! println!("Please call {} at the number {}", p.name, p.phones[0]);
+//!
+//! Ok(())
+//! }
+//! #
+//! # fn main() {
+//! # typed_example().unwrap();
+//! # }
+//! ```
+//!
+//! This is the same `serde_json::from_str` function as before, but this time we
+//! assign the return value to a variable of type `Person` so Serde will
+//! automatically interpret the input data as a `Person` and produce informative
+//! error messages if the layout does not conform to what a `Person` is expected
+//! to look like.
+//!
+//! Any type that implements Serde's `Deserialize` trait can be deserialized
+//! this way. This includes built-in Rust standard library types like `Vec<T>`
+//! and `HashMap<K, V>`, as well as any structs or enums annotated with
+//! `#[derive(Deserialize)]`.
+//!
+//! Once we have `p` of type `Person`, our IDE and the Rust compiler can help us
+//! use it correctly like they do for any other Rust code. The IDE can
+//! autocomplete field names to prevent typos, which was impossible in the
+//! `serde_json::Value` representation. And the Rust compiler can check that
+//! when we write `p.phones[0]`, then `p.phones` is guaranteed to be a
+//! `Vec<String>` so indexing into it makes sense and produces a `String`.
+//!
+//! # Constructing JSON values
+//!
+//! Serde JSON provides a [`json!` macro][macro] to build `serde_json::Value`
+//! objects with very natural JSON syntax. In order to use this macro,
+//! `serde_json` needs to be imported with the `#[macro_use]` attribute.
+//!
+//! ```rust
+//! #[macro_use]
+//! extern crate serde_json;
+//!
+//! fn main() {
+//! // The type of `john` is `serde_json::Value`
+//! let john = json!({
+//! "name": "John Doe",
+//! "age": 43,
+//! "phones": [
+//! "+44 1234567",
+//! "+44 2345678"
+//! ]
+//! });
+//!
+//! println!("first phone number: {}", john["phones"][0]);
+//!
+//! // Convert to a string of JSON and print it out
+//! println!("{}", john.to_string());
+//! }
+//! ```
+//!
+//! The `Value::to_string()` function converts a `serde_json::Value` into a
+//! `String` of JSON text.
+//!
+//! One neat thing about the `json!` macro is that variables and expressions can
+//! be interpolated directly into the JSON value as you are building it. Serde
+//! will check at compile time that the value you are interpolating is able to
+//! be represented as JSON.
+//!
+//! ```rust
+//! # #[macro_use]
+//! # extern crate serde_json;
+//! #
+//! # fn random_phone() -> u16 { 0 }
+//! #
+//! # fn main() {
+//! let full_name = "John Doe";
+//! let age_last_year = 42;
+//!
+//! // The type of `john` is `serde_json::Value`
+//! let john = json!({
+//! "name": full_name,
+//! "age": age_last_year + 1,
+//! "phones": [
+//! format!("+44 {}", random_phone())
+//! ]
+//! });
+//! # let _ = john;
+//! # }
+//! ```
+//!
+//! This is amazingly convenient but we have the problem we had before with
+//! `Value` which is that the IDE and Rust compiler cannot help us if we get it
+//! wrong. Serde JSON provides a better way of serializing strongly-typed data
+//! structures into JSON text.
+//!
+//! # Creating JSON by serializing data structures
+//!
+//! A data structure can be converted to a JSON string by
+//! [`serde_json::to_string`][to_string]. There is also
+//! [`serde_json::to_vec`][to_vec] which serializes to a `Vec<u8>` and
+//! [`serde_json::to_writer`][to_writer] which serializes to any `io::Write`
+//! such as a File or a TCP stream.
+//!
+//! ```rust
+//! extern crate serde;
+//! extern crate serde_json;
+//!
+//! #[macro_use]
+//! extern crate serde_derive;
+//!
+//! use serde_json::Error;
+//!
+//! #[derive(Serialize, Deserialize)]
+//! struct Address {
+//! street: String,
+//! city: String,
+//! }
+//!
+//! fn print_an_address() -> Result<(), Error> {
+//! // Some data structure.
+//! let address = Address {
+//! street: "10 Downing Street".to_owned(),
+//! city: "London".to_owned(),
+//! };
+//!
+//! // Serialize it to a JSON string.
+//! let j = serde_json::to_string(&address)?;
+//!
+//! // Print, write to a file, or send to an HTTP server.
+//! println!("{}", j);
+//!
+//! Ok(())
+//! }
+//! #
+//! # fn main() {
+//! # print_an_address().unwrap();
+//! # }
+//! ```
+//!
+//! Any type that implements Serde's `Serialize` trait can be serialized this
+//! way. This includes built-in Rust standard library types like `Vec<T>` and
+//! `HashMap<K, V>`, as well as any structs or enums annotated with
+//! `#[derive(Serialize)]`.
+//!
+//! # No-std support
+//!
+//! This crate currently requires the Rust standard library. For JSON support in
+//! Serde without a standard library, please see the [`serde-json-core`] crate.
+//!
+//! [value]: https://docs.serde.rs/serde_json/value/enum.Value.html
+//! [from_str]: https://docs.serde.rs/serde_json/de/fn.from_str.html
+//! [from_slice]: https://docs.serde.rs/serde_json/de/fn.from_slice.html
+//! [from_reader]: https://docs.serde.rs/serde_json/de/fn.from_reader.html
+//! [to_string]: https://docs.serde.rs/serde_json/ser/fn.to_string.html
+//! [to_vec]: https://docs.serde.rs/serde_json/ser/fn.to_vec.html
+//! [to_writer]: https://docs.serde.rs/serde_json/ser/fn.to_writer.html
+//! [macro]: https://docs.serde.rs/serde_json/macro.json.html
+//! [`serde-json-core`]: https://japaric.github.io/serde-json-core/serde_json_core/
+
+#![doc(html_root_url = "https://docs.rs/serde_json/1.0.22")]
+#![cfg_attr(feature = "cargo-clippy", deny(clippy, clippy_pedantic))]
+// Whitelisted clippy lints
+#![cfg_attr(feature = "cargo-clippy", allow(doc_markdown, needless_pass_by_value))]
+// Whitelisted clippy_pedantic lints
+#![cfg_attr(feature = "cargo-clippy", allow(
+// Deserializer::from_str, into_iter
+ should_implement_trait,
+// integer and float ser/de requires these sorts of casts
+ cast_possible_truncation,
+ cast_possible_wrap,
+ cast_precision_loss,
+ cast_sign_loss,
+// string ser/de uses indexing and slicing
+ indexing_slicing,
+// things are often more readable this way
+ cast_lossless,
+ shadow_reuse,
+ shadow_unrelated,
+ single_match_else,
+ stutter,
+ use_self,
+// not practical
+ missing_docs_in_private_items,
+ similar_names,
+// we support older compilers
+ redundant_field_names,
+))]
+#![deny(missing_docs)]
+
+#[macro_use]
+extern crate serde;
+extern crate dtoa;
+#[cfg(feature = "preserve_order")]
+extern crate indexmap;
+extern crate itoa;
+
+#[doc(inline)]
+pub use self::de::{from_reader, from_slice, from_str, Deserializer, StreamDeserializer};
+#[doc(inline)]
+pub use self::error::{Error, Result};
+#[doc(inline)]
+pub use self::ser::{
+ to_string, to_string_pretty, to_vec, to_vec_pretty, to_writer, to_writer_pretty, Serializer,
+};
+#[doc(inline)]
+pub use self::value::{from_value, to_value, Map, Number, Value};
+
+// We only use our own error type; no need for From conversions provided by the
+// standard library's try! macro. This reduces lines of LLVM IR by 4%.
+macro_rules! try {
+ ($e:expr) => {
+ match $e {
+ ::std::result::Result::Ok(val) => val,
+ ::std::result::Result::Err(err) => return ::std::result::Result::Err(err),
+ }
+ };
+}
+
+#[macro_use]
+mod macros;
+
+pub mod de;
+pub mod error;
+pub mod map;
+pub mod ser;
+pub mod value;
+
+mod iter;
+mod number;
+mod read;
new file mode 100644
--- /dev/null
+++ b/third_party/rust/serde_json/src/macros.rs
@@ -0,0 +1,298 @@
+// Copyright 2017 Serde Developers
+//
+// Licensed under the Apache License, Version 2.0 <LICENSE-APACHE or
+// http://www.apache.org/licenses/LICENSE-2.0> or the MIT license
+// <LICENSE-MIT or http://opensource.org/licenses/MIT>, at your
+// option. This file may not be copied, modified, or distributed
+// except according to those terms.
+
+/// Construct a `serde_json::Value` from a JSON literal.
+///
+/// ```rust
+/// # #[macro_use]
+/// # extern crate serde_json;
+/// #
+/// # fn main() {
+/// let value = json!({
+/// "code": 200,
+/// "success": true,
+/// "payload": {
+/// "features": [
+/// "serde",
+/// "json"
+/// ]
+/// }
+/// });
+/// # }
+/// ```
+///
+/// Variables or expressions can be interpolated into the JSON literal. Any type
+/// interpolated into an array element or object value must implement Serde's
+/// `Serialize` trait, while any type interpolated into a object key must
+/// implement `Into<String>`. If the `Serialize` implementation of the
+/// interpolated type decides to fail, or if the interpolated type contains a
+/// map with non-string keys, the `json!` macro will panic.
+///
+/// ```rust
+/// # #[macro_use]
+/// # extern crate serde_json;
+/// #
+/// # fn main() {
+/// let code = 200;
+/// let features = vec!["serde", "json"];
+///
+/// let value = json!({
+/// "code": code,
+/// "success": code == 200,
+/// "payload": {
+/// features[0]: features[1]
+/// }
+/// });
+/// # }
+/// ```
+///
+/// Trailing commas are allowed inside both arrays and objects.
+///
+/// ```rust
+/// # #[macro_use]
+/// # extern crate serde_json;
+/// #
+/// # fn main() {
+/// let value = json!([
+/// "notice",
+/// "the",
+/// "trailing",
+/// "comma -->",
+/// ]);
+/// # }
+/// ```
+#[macro_export]
+macro_rules! json {
+ // Hide distracting implementation details from the generated rustdoc.
+ ($($json:tt)+) => {
+ json_internal!($($json)+)
+ };
+}
+
+// Rocket relies on this because they export their own `json!` with a different
+// doc comment than ours, and various Rust bugs prevent them from calling our
+// `json!` from their `json!` so they call `json_internal!` directly. Check with
+// @SergioBenitez before making breaking changes to this macro.
+//
+// Changes are fine as long as `json_internal!` does not call any new helper
+// macros and can still be invoked as `json_internal!($($json)+)`.
+#[macro_export]
+#[doc(hidden)]
+macro_rules! json_internal {
+ //////////////////////////////////////////////////////////////////////////
+ // TT muncher for parsing the inside of an array [...]. Produces a vec![...]
+ // of the elements.
+ //
+ // Must be invoked as: json_internal!(@array [] $($tt)*)
+ //////////////////////////////////////////////////////////////////////////
+
+ // Done with trailing comma.
+ (@array [$($elems:expr,)*]) => {
+ vec![$($elems,)*]
+ };
+
+ // Done without trailing comma.
+ (@array [$($elems:expr),*]) => {
+ vec![$($elems),*]
+ };
+
+ // Next element is `null`.
+ (@array [$($elems:expr,)*] null $($rest:tt)*) => {
+ json_internal!(@array [$($elems,)* json_internal!(null)] $($rest)*)
+ };
+
+ // Next element is `true`.
+ (@array [$($elems:expr,)*] true $($rest:tt)*) => {
+ json_internal!(@array [$($elems,)* json_internal!(true)] $($rest)*)
+ };
+
+ // Next element is `false`.
+ (@array [$($elems:expr,)*] false $($rest:tt)*) => {
+ json_internal!(@array [$($elems,)* json_internal!(false)] $($rest)*)
+ };
+
+ // Next element is an array.
+ (@array [$($elems:expr,)*] [$($array:tt)*] $($rest:tt)*) => {
+ json_internal!(@array [$($elems,)* json_internal!([$($array)*])] $($rest)*)
+ };
+
+ // Next element is a map.
+ (@array [$($elems:expr,)*] {$($map:tt)*} $($rest:tt)*) => {
+ json_internal!(@array [$($elems,)* json_internal!({$($map)*})] $($rest)*)
+ };
+
+ // Next element is an expression followed by comma.
+ (@array [$($elems:expr,)*] $next:expr, $($rest:tt)*) => {
+ json_internal!(@array [$($elems,)* json_internal!($next),] $($rest)*)
+ };
+
+ // Last element is an expression with no trailing comma.
+ (@array [$($elems:expr,)*] $last:expr) => {
+ json_internal!(@array [$($elems,)* json_internal!($last)])
+ };
+
+ // Comma after the most recent element.
+ (@array [$($elems:expr),*] , $($rest:tt)*) => {
+ json_internal!(@array [$($elems,)*] $($rest)*)
+ };
+
+ // Unexpected token after most recent element.
+ (@array [$($elems:expr),*] $unexpected:tt $($rest:tt)*) => {
+ json_unexpected!($unexpected)
+ };
+
+ //////////////////////////////////////////////////////////////////////////
+ // TT muncher for parsing the inside of an object {...}. Each entry is
+ // inserted into the given map variable.
+ //
+ // Must be invoked as: json_internal!(@object $map () ($($tt)*) ($($tt)*))
+ //
+ // We require two copies of the input tokens so that we can match on one
+ // copy and trigger errors on the other copy.
+ //////////////////////////////////////////////////////////////////////////
+
+ // Done.
+ (@object $object:ident () () ()) => {};
+
+ // Insert the current entry followed by trailing comma.
+ (@object $object:ident [$($key:tt)+] ($value:expr) , $($rest:tt)*) => {
+ $object.insert(($($key)+).into(), $value);
+ json_internal!(@object $object () ($($rest)*) ($($rest)*));
+ };
+
+ // Current entry followed by unexpected token.
+ (@object $object:ident [$($key:tt)+] ($value:expr) $unexpected:tt $($rest:tt)*) => {
+ json_unexpected!($unexpected);
+ };
+
+ // Insert the last entry without trailing comma.
+ (@object $object:ident [$($key:tt)+] ($value:expr)) => {
+ $object.insert(($($key)+).into(), $value);
+ };
+
+ // Next value is `null`.
+ (@object $object:ident ($($key:tt)+) (: null $($rest:tt)*) $copy:tt) => {
+ json_internal!(@object $object [$($key)+] (json_internal!(null)) $($rest)*);
+ };
+
+ // Next value is `true`.
+ (@object $object:ident ($($key:tt)+) (: true $($rest:tt)*) $copy:tt) => {
+ json_internal!(@object $object [$($key)+] (json_internal!(true)) $($rest)*);
+ };
+
+ // Next value is `false`.
+ (@object $object:ident ($($key:tt)+) (: false $($rest:tt)*) $copy:tt) => {
+ json_internal!(@object $object [$($key)+] (json_internal!(false)) $($rest)*);
+ };
+
+ // Next value is an array.
+ (@object $object:ident ($($key:tt)+) (: [$($array:tt)*] $($rest:tt)*) $copy:tt) => {
+ json_internal!(@object $object [$($key)+] (json_internal!([$($array)*])) $($rest)*);
+ };
+
+ // Next value is a map.
+ (@object $object:ident ($($key:tt)+) (: {$($map:tt)*} $($rest:tt)*) $copy:tt) => {
+ json_internal!(@object $object [$($key)+] (json_internal!({$($map)*})) $($rest)*);
+ };
+
+ // Next value is an expression followed by comma.
+ (@object $object:ident ($($key:tt)+) (: $value:expr , $($rest:tt)*) $copy:tt) => {
+ json_internal!(@object $object [$($key)+] (json_internal!($value)) , $($rest)*);
+ };
+
+ // Last value is an expression with no trailing comma.
+ (@object $object:ident ($($key:tt)+) (: $value:expr) $copy:tt) => {
+ json_internal!(@object $object [$($key)+] (json_internal!($value)));
+ };
+
+ // Missing value for last entry. Trigger a reasonable error message.
+ (@object $object:ident ($($key:tt)+) (:) $copy:tt) => {
+ // "unexpected end of macro invocation"
+ json_internal!();
+ };
+
+ // Missing colon and value for last entry. Trigger a reasonable error
+ // message.
+ (@object $object:ident ($($key:tt)+) () $copy:tt) => {
+ // "unexpected end of macro invocation"
+ json_internal!();
+ };
+
+ // Misplaced colon. Trigger a reasonable error message.
+ (@object $object:ident () (: $($rest:tt)*) ($colon:tt $($copy:tt)*)) => {
+ // Takes no arguments so "no rules expected the token `:`".
+ json_unexpected!($colon);
+ };
+
+ // Found a comma inside a key. Trigger a reasonable error message.
+ (@object $object:ident ($($key:tt)*) (, $($rest:tt)*) ($comma:tt $($copy:tt)*)) => {
+ // Takes no arguments so "no rules expected the token `,`".
+ json_unexpected!($comma);
+ };
+
+ // Key is fully parenthesized. This avoids clippy double_parens false
+ // positives because the parenthesization may be necessary here.
+ (@object $object:ident () (($key:expr) : $($rest:tt)*) $copy:tt) => {
+ json_internal!(@object $object ($key) (: $($rest)*) (: $($rest)*));
+ };
+
+ // Munch a token into the current key.
+ (@object $object:ident ($($key:tt)*) ($tt:tt $($rest:tt)*) $copy:tt) => {
+ json_internal!(@object $object ($($key)* $tt) ($($rest)*) ($($rest)*));
+ };
+
+ //////////////////////////////////////////////////////////////////////////
+ // The main implementation.
+ //
+ // Must be invoked as: json_internal!($($json)+)
+ //////////////////////////////////////////////////////////////////////////
+
+ (null) => {
+ $crate::Value::Null
+ };
+
+ (true) => {
+ $crate::Value::Bool(true)
+ };
+
+ (false) => {
+ $crate::Value::Bool(false)
+ };
+
+ ([]) => {
+ $crate::Value::Array(vec![])
+ };
+
+ ([ $($tt:tt)+ ]) => {
+ $crate::Value::Array(json_internal!(@array [] $($tt)+))
+ };
+
+ ({}) => {
+ $crate::Value::Object($crate::Map::new())
+ };
+
+ ({ $($tt:tt)+ }) => {
+ $crate::Value::Object({
+ let mut object = $crate::Map::new();
+ json_internal!(@object object () ($($tt)+) ($($tt)+));
+ object
+ })
+ };
+
+ // Any Serialize type: numbers, strings, struct literals, variables etc.
+ // Must be below every other rule.
+ ($other:expr) => {
+ $crate::to_value(&$other).unwrap()
+ };
+}
+
+#[macro_export]
+#[doc(hidden)]
+macro_rules! json_unexpected {
+ () => {};
+}
new file mode 100644
--- /dev/null
+++ b/third_party/rust/serde_json/src/map.rs
@@ -0,0 +1,853 @@
+// Copyright 2017 Serde Developers
+//
+// Licensed under the Apache License, Version 2.0 <LICENSE-APACHE or
+// http://www.apache.org/licenses/LICENSE-2.0> or the MIT license
+// <LICENSE-MIT or http://opensource.org/licenses/MIT>, at your
+// option. This file may not be copied, modified, or distributed
+// except according to those terms.
+
+//! A map of String to serde_json::Value.
+//!
+//! By default the map is backed by a [`BTreeMap`]. Enable the `preserve_order`
+//! feature of serde_json to use [`IndexMap`] instead.
+//!
+//! [`BTreeMap`]: https://doc.rust-lang.org/std/collections/struct.BTreeMap.html
+//! [`IndexMap`]: https://docs.rs/indexmap/*/indexmap/map/struct.IndexMap.html
+
+use serde::{de, ser};
+use std::borrow::Borrow;
+use std::fmt::{self, Debug};
+use std::hash::Hash;
+use std::iter::FromIterator;
+use std::ops;
+use value::Value;
+
+#[cfg(not(feature = "preserve_order"))]
+use std::collections::{btree_map, BTreeMap};
+
+#[cfg(feature = "preserve_order")]
+use indexmap::{self, IndexMap};
+
+/// Represents a JSON key/value type.
+pub struct Map<K, V> {
+ map: MapImpl<K, V>,
+}
+
+#[cfg(not(feature = "preserve_order"))]
+type MapImpl<K, V> = BTreeMap<K, V>;
+#[cfg(feature = "preserve_order")]
+type MapImpl<K, V> = IndexMap<K, V>;
+
+impl Map<String, Value> {
+ /// Makes a new empty Map.
+ #[inline]
+ pub fn new() -> Self {
+ Map {
+ map: MapImpl::new(),
+ }
+ }
+
+ #[cfg(not(feature = "preserve_order"))]
+ /// Makes a new empty Map with the given initial capacity.
+ #[inline]
+ pub fn with_capacity(capacity: usize) -> Self {
+ // does not support with_capacity
+ let _ = capacity;
+ Map {
+ map: BTreeMap::new(),
+ }
+ }
+
+ #[cfg(feature = "preserve_order")]
+ /// Makes a new empty Map with the given initial capacity.
+ #[inline]
+ pub fn with_capacity(capacity: usize) -> Self {
+ Map {
+ map: IndexMap::with_capacity(capacity),
+ }
+ }
+
+ /// Clears the map, removing all values.
+ #[inline]
+ pub fn clear(&mut self) {
+ self.map.clear()
+ }
+
+ /// Returns a reference to the value corresponding to the key.
+ ///
+ /// The key may be any borrowed form of the map's key type, but the ordering
+ /// on the borrowed form *must* match the ordering on the key type.
+ #[inline]
+ pub fn get<Q: ?Sized>(&self, key: &Q) -> Option<&Value>
+ where
+ String: Borrow<Q>,
+ Q: Ord + Eq + Hash,
+ {
+ self.map.get(key)
+ }
+
+ /// Returns true if the map contains a value for the specified key.
+ ///
+ /// The key may be any borrowed form of the map's key type, but the ordering
+ /// on the borrowed form *must* match the ordering on the key type.
+ #[inline]
+ pub fn contains_key<Q: ?Sized>(&self, key: &Q) -> bool
+ where
+ String: Borrow<Q>,
+ Q: Ord + Eq + Hash,
+ {
+ self.map.contains_key(key)
+ }
+
+ /// Returns a mutable reference to the value corresponding to the key.
+ ///
+ /// The key may be any borrowed form of the map's key type, but the ordering
+ /// on the borrowed form *must* match the ordering on the key type.
+ #[inline]
+ pub fn get_mut<Q: ?Sized>(&mut self, key: &Q) -> Option<&mut Value>
+ where
+ String: Borrow<Q>,
+ Q: Ord + Eq + Hash,
+ {
+ self.map.get_mut(key)
+ }
+
+ /// Inserts a key-value pair into the map.
+ ///
+ /// If the map did not have this key present, `None` is returned.
+ ///
+ /// If the map did have this key present, the value is updated, and the old
+ /// value is returned. The key is not updated, though; this matters for
+ /// types that can be `==` without being identical.
+ #[inline]
+ pub fn insert(&mut self, k: String, v: Value) -> Option<Value> {
+ self.map.insert(k, v)
+ }
+
+ /// Removes a key from the map, returning the value at the key if the key
+ /// was previously in the map.
+ ///
+ /// The key may be any borrowed form of the map's key type, but the ordering
+ /// on the borrowed form *must* match the ordering on the key type.
+ #[inline]
+ pub fn remove<Q: ?Sized>(&mut self, key: &Q) -> Option<Value>
+ where
+ String: Borrow<Q>,
+ Q: Ord + Eq + Hash,
+ {
+ self.map.remove(key)
+ }
+
+ /// Gets the given key's corresponding entry in the map for in-place
+ /// manipulation.
+ pub fn entry<S>(&mut self, key: S) -> Entry
+ where
+ S: Into<String>,
+ {
+ #[cfg(feature = "preserve_order")]
+ use indexmap::map::Entry as EntryImpl;
+ #[cfg(not(feature = "preserve_order"))]
+ use std::collections::btree_map::Entry as EntryImpl;
+
+ match self.map.entry(key.into()) {
+ EntryImpl::Vacant(vacant) => Entry::Vacant(VacantEntry { vacant: vacant }),
+ EntryImpl::Occupied(occupied) => Entry::Occupied(OccupiedEntry { occupied: occupied }),
+ }
+ }
+
+ /// Returns the number of elements in the map.
+ #[inline]
+ pub fn len(&self) -> usize {
+ self.map.len()
+ }
+
+ /// Returns true if the map contains no elements.
+ #[inline]
+ pub fn is_empty(&self) -> bool {
+ self.map.is_empty()
+ }
+
+ /// Gets an iterator over the entries of the map.
+ #[inline]
+ pub fn iter(&self) -> Iter {
+ Iter {
+ iter: self.map.iter(),
+ }
+ }
+
+ /// Gets a mutable iterator over the entries of the map.
+ #[inline]
+ pub fn iter_mut(&mut self) -> IterMut {
+ IterMut {
+ iter: self.map.iter_mut(),
+ }
+ }
+
+ /// Gets an iterator over the keys of the map.
+ #[inline]
+ pub fn keys(&self) -> Keys {
+ Keys {
+ iter: self.map.keys(),
+ }
+ }
+
+ /// Gets an iterator over the values of the map.
+ #[inline]
+ pub fn values(&self) -> Values {
+ Values {
+ iter: self.map.values(),
+ }
+ }
+
+ /// Gets an iterator over mutable values of the map.
+ #[inline]
+ pub fn values_mut(&mut self) -> ValuesMut {
+ ValuesMut {
+ iter: self.map.values_mut(),
+ }
+ }
+}
+
+impl Default for Map<String, Value> {
+ #[inline]
+ fn default() -> Self {
+ Map {
+ map: MapImpl::new(),
+ }
+ }
+}
+
+impl Clone for Map<String, Value> {
+ #[inline]
+ fn clone(&self) -> Self {
+ Map {
+ map: self.map.clone(),
+ }
+ }
+}
+
+impl PartialEq for Map<String, Value> {
+ #[inline]
+ fn eq(&self, other: &Self) -> bool {
+ if cfg!(feature = "preserve_order") {
+ if self.len() != other.len() {
+ return false;
+ }
+
+ self.iter()
+ .all(|(key, value)| other.get(key).map_or(false, |v| *value == *v))
+ } else {
+ self.map.eq(&other.map)
+ }
+ }
+}
+
+/// Access an element of this map. Panics if the given key is not present in the
+/// map.
+///
+/// ```rust
+/// # use serde_json::Value;
+/// #
+/// # let val = &Value::String("".to_owned());
+/// # let _ =
+/// match *val {
+/// Value::String(ref s) => Some(s.as_str()),
+/// Value::Array(ref arr) => arr[0].as_str(),
+/// Value::Object(ref map) => map["type"].as_str(),
+/// _ => None,
+/// }
+/// # ;
+/// ```
+impl<'a, Q: ?Sized> ops::Index<&'a Q> for Map<String, Value>
+where
+ String: Borrow<Q>,
+ Q: Ord + Eq + Hash,
+{
+ type Output = Value;
+
+ fn index(&self, index: &Q) -> &Value {
+ self.map.index(index)
+ }
+}
+
+/// Mutably access an element of this map. Panics if the given key is not
+/// present in the map.
+///
+/// ```rust
+/// # #[macro_use]
+/// # extern crate serde_json;
+/// #
+/// # fn main() {
+/// # let mut map = serde_json::Map::new();
+/// # map.insert("key".to_owned(), serde_json::Value::Null);
+/// #
+/// map["key"] = json!("value");
+/// # }
+/// ```
+impl<'a, Q: ?Sized> ops::IndexMut<&'a Q> for Map<String, Value>
+where
+ String: Borrow<Q>,
+ Q: Ord + Eq + Hash,
+{
+ fn index_mut(&mut self, index: &Q) -> &mut Value {
+ self.map.get_mut(index).expect("no entry found for key")
+ }
+}
+
+impl Debug for Map<String, Value> {
+ #[inline]
+ fn fmt(&self, formatter: &mut fmt::Formatter) -> Result<(), fmt::Error> {
+ self.map.fmt(formatter)
+ }
+}
+
+impl ser::Serialize for Map<String, Value> {
+ #[inline]
+ fn serialize<S>(&self, serializer: S) -> Result<S::Ok, S::Error>
+ where
+ S: ser::Serializer,
+ {
+ use serde::ser::SerializeMap;
+ let mut map = try!(serializer.serialize_map(Some(self.len())));
+ for (k, v) in self {
+ try!(map.serialize_key(k));
+ try!(map.serialize_value(v));
+ }
+ map.end()
+ }
+}
+
+impl<'de> de::Deserialize<'de> for Map<String, Value> {
+ #[inline]
+ fn deserialize<D>(deserializer: D) -> Result<Self, D::Error>
+ where
+ D: de::Deserializer<'de>,
+ {
+ struct Visitor;
+
+ impl<'de> de::Visitor<'de> for Visitor {
+ type Value = Map<String, Value>;
+
+ fn expecting(&self, formatter: &mut fmt::Formatter) -> fmt::Result {
+ formatter.write_str("a map")
+ }
+
+ #[inline]
+ fn visit_unit<E>(self) -> Result<Self::Value, E>
+ where
+ E: de::Error,
+ {
+ Ok(Map::new())
+ }
+
+ #[inline]
+ fn visit_map<V>(self, mut visitor: V) -> Result<Self::Value, V::Error>
+ where
+ V: de::MapAccess<'de>,
+ {
+ let mut values = Map::new();
+
+ while let Some((key, value)) = try!(visitor.next_entry()) {
+ values.insert(key, value);
+ }
+
+ Ok(values)
+ }
+ }
+
+ deserializer.deserialize_map(Visitor)
+ }
+}
+
+impl FromIterator<(String, Value)> for Map<String, Value> {
+ fn from_iter<T>(iter: T) -> Self
+ where
+ T: IntoIterator<Item = (String, Value)>,
+ {
+ Map {
+ map: FromIterator::from_iter(iter),
+ }
+ }
+}
+
+impl Extend<(String, Value)> for Map<String, Value> {
+ fn extend<T>(&mut self, iter: T)
+ where
+ T: IntoIterator<Item = (String, Value)>,
+ {
+ self.map.extend(iter);
+ }
+}
+
+macro_rules! delegate_iterator {
+ (($name:ident $($generics:tt)*) => $item:ty) => {
+ impl $($generics)* Iterator for $name $($generics)* {
+ type Item = $item;
+ #[inline]
+ fn next(&mut self) -> Option<Self::Item> {
+ self.iter.next()
+ }
+ #[inline]
+ fn size_hint(&self) -> (usize, Option<usize>) {
+ self.iter.size_hint()
+ }
+ }
+
+ impl $($generics)* DoubleEndedIterator for $name $($generics)* {
+ #[inline]
+ fn next_back(&mut self) -> Option<Self::Item> {
+ self.iter.next_back()
+ }
+ }
+
+ impl $($generics)* ExactSizeIterator for $name $($generics)* {
+ #[inline]
+ fn len(&self) -> usize {
+ self.iter.len()
+ }
+ }
+ }
+}
+
+//////////////////////////////////////////////////////////////////////////////
+
+/// A view into a single entry in a map, which may either be vacant or occupied.
+/// This enum is constructed from the [`entry`] method on [`Map`].
+///
+/// [`entry`]: struct.Map.html#method.entry
+/// [`Map`]: struct.Map.html
+pub enum Entry<'a> {
+ /// A vacant Entry.
+ Vacant(VacantEntry<'a>),
+ /// An occupied Entry.
+ Occupied(OccupiedEntry<'a>),
+}
+
+/// A vacant Entry. It is part of the [`Entry`] enum.
+///
+/// [`Entry`]: enum.Entry.html
+pub struct VacantEntry<'a> {
+ vacant: VacantEntryImpl<'a>,
+}
+
+/// An occupied Entry. It is part of the [`Entry`] enum.
+///
+/// [`Entry`]: enum.Entry.html
+pub struct OccupiedEntry<'a> {
+ occupied: OccupiedEntryImpl<'a>,
+}
+
+#[cfg(not(feature = "preserve_order"))]
+type VacantEntryImpl<'a> = btree_map::VacantEntry<'a, String, Value>;
+#[cfg(feature = "preserve_order")]
+type VacantEntryImpl<'a> = indexmap::map::VacantEntry<'a, String, Value>;
+
+#[cfg(not(feature = "preserve_order"))]
+type OccupiedEntryImpl<'a> = btree_map::OccupiedEntry<'a, String, Value>;
+#[cfg(feature = "preserve_order")]
+type OccupiedEntryImpl<'a> = indexmap::map::OccupiedEntry<'a, String, Value>;
+
+impl<'a> Entry<'a> {
+ /// Returns a reference to this entry's key.
+ ///
+ /// # Examples
+ ///
+ /// ```rust
+ /// let mut map = serde_json::Map::new();
+ /// assert_eq!(map.entry("serde").key(), &"serde");
+ /// ```
+ pub fn key(&self) -> &String {
+ match *self {
+ Entry::Vacant(ref e) => e.key(),
+ Entry::Occupied(ref e) => e.key(),
+ }
+ }
+
+ /// Ensures a value is in the entry by inserting the default if empty, and
+ /// returns a mutable reference to the value in the entry.
+ ///
+ /// # Examples
+ ///
+ /// ```rust
+ /// # #[macro_use]
+ /// # extern crate serde_json;
+ /// #
+ /// # fn main() {
+ /// let mut map = serde_json::Map::new();
+ /// map.entry("serde").or_insert(json!(12));
+ ///
+ /// assert_eq!(map["serde"], 12);
+ /// # }
+ /// ```
+ pub fn or_insert(self, default: Value) -> &'a mut Value {
+ match self {
+ Entry::Vacant(entry) => entry.insert(default),
+ Entry::Occupied(entry) => entry.into_mut(),
+ }
+ }
+
+ /// Ensures a value is in the entry by inserting the result of the default
+ /// function if empty, and returns a mutable reference to the value in the
+ /// entry.
+ ///
+ /// # Examples
+ ///
+ /// ```rust
+ /// # #[macro_use]
+ /// # extern crate serde_json;
+ /// #
+ /// # fn main() {
+ /// let mut map = serde_json::Map::new();
+ /// map.entry("serde").or_insert_with(|| json!("hoho"));
+ ///
+ /// assert_eq!(map["serde"], "hoho".to_owned());
+ /// # }
+ /// ```
+ pub fn or_insert_with<F>(self, default: F) -> &'a mut Value
+ where
+ F: FnOnce() -> Value,
+ {
+ match self {
+ Entry::Vacant(entry) => entry.insert(default()),
+ Entry::Occupied(entry) => entry.into_mut(),
+ }
+ }
+}
+
+impl<'a> VacantEntry<'a> {
+ /// Gets a reference to the key that would be used when inserting a value
+ /// through the VacantEntry.
+ ///
+ /// # Examples
+ ///
+ /// ```rust
+ /// use serde_json::map::Entry;
+ ///
+ /// let mut map = serde_json::Map::new();
+ ///
+ /// match map.entry("serde") {
+ /// Entry::Vacant(vacant) => {
+ /// assert_eq!(vacant.key(), &"serde");
+ /// }
+ /// Entry::Occupied(_) => unimplemented!(),
+ /// }
+ /// ```
+ #[inline]
+ pub fn key(&self) -> &String {
+ self.vacant.key()
+ }
+
+ /// Sets the value of the entry with the VacantEntry's key, and returns a
+ /// mutable reference to it.
+ ///
+ /// # Examples
+ ///
+ /// ```rust
+ /// # #[macro_use]
+ /// # extern crate serde_json;
+ /// #
+ /// # fn main() {
+ /// use serde_json::map::Entry;
+ ///
+ /// let mut map = serde_json::Map::new();
+ ///
+ /// match map.entry("serde") {
+ /// Entry::Vacant(vacant) => {
+ /// vacant.insert(json!("hoho"));
+ /// }
+ /// Entry::Occupied(_) => unimplemented!(),
+ /// }
+ /// # }
+ /// ```
+ #[inline]
+ pub fn insert(self, value: Value) -> &'a mut Value {
+ self.vacant.insert(value)
+ }
+}
+
+impl<'a> OccupiedEntry<'a> {
+ /// Gets a reference to the key in the entry.
+ ///
+ /// # Examples
+ ///
+ /// ```rust
+ /// # #[macro_use]
+ /// # extern crate serde_json;
+ /// #
+ /// # fn main() {
+ /// use serde_json::map::Entry;
+ ///
+ /// let mut map = serde_json::Map::new();
+ /// map.insert("serde".to_owned(), json!(12));
+ ///
+ /// match map.entry("serde") {
+ /// Entry::Occupied(occupied) => {
+ /// assert_eq!(occupied.key(), &"serde");
+ /// }
+ /// Entry::Vacant(_) => unimplemented!(),
+ /// }
+ /// # }
+ /// ```
+ #[inline]
+ pub fn key(&self) -> &String {
+ self.occupied.key()
+ }
+
+ /// Gets a reference to the value in the entry.
+ ///
+ /// # Examples
+ ///
+ /// ```rust
+ /// # #[macro_use]
+ /// # extern crate serde_json;
+ /// #
+ /// # fn main() {
+ /// use serde_json::map::Entry;
+ ///
+ /// let mut map = serde_json::Map::new();
+ /// map.insert("serde".to_owned(), json!(12));
+ ///
+ /// match map.entry("serde") {
+ /// Entry::Occupied(occupied) => {
+ /// assert_eq!(occupied.get(), 12);
+ /// }
+ /// Entry::Vacant(_) => unimplemented!(),
+ /// }
+ /// # }
+ /// ```
+ #[inline]
+ pub fn get(&self) -> &Value {
+ self.occupied.get()
+ }
+
+ /// Gets a mutable reference to the value in the entry.
+ ///
+ /// # Examples
+ ///
+ /// ```rust
+ /// # #[macro_use]
+ /// # extern crate serde_json;
+ /// #
+ /// # fn main() {
+ /// use serde_json::map::Entry;
+ ///
+ /// let mut map = serde_json::Map::new();
+ /// map.insert("serde".to_owned(), json!([1, 2, 3]));
+ ///
+ /// match map.entry("serde") {
+ /// Entry::Occupied(mut occupied) => {
+ /// occupied.get_mut().as_array_mut().unwrap().push(json!(4));
+ /// }
+ /// Entry::Vacant(_) => unimplemented!(),
+ /// }
+ ///
+ /// assert_eq!(map["serde"].as_array().unwrap().len(), 4);
+ /// # }
+ /// ```
+ #[inline]
+ pub fn get_mut(&mut self) -> &mut Value {
+ self.occupied.get_mut()
+ }
+
+ /// Converts the entry into a mutable reference to its value.
+ ///
+ /// # Examples
+ ///
+ /// ```rust
+ /// # #[macro_use]
+ /// # extern crate serde_json;
+ /// #
+ /// # fn main() {
+ /// use serde_json::map::Entry;
+ ///
+ /// let mut map = serde_json::Map::new();
+ /// map.insert("serde".to_owned(), json!([1, 2, 3]));
+ ///
+ /// match map.entry("serde") {
+ /// Entry::Occupied(mut occupied) => {
+ /// occupied.into_mut().as_array_mut().unwrap().push(json!(4));
+ /// }
+ /// Entry::Vacant(_) => unimplemented!(),
+ /// }
+ ///
+ /// assert_eq!(map["serde"].as_array().unwrap().len(), 4);
+ /// # }
+ /// ```
+ #[inline]
+ pub fn into_mut(self) -> &'a mut Value {
+ self.occupied.into_mut()
+ }
+
+ /// Sets the value of the entry with the `OccupiedEntry`'s key, and returns
+ /// the entry's old value.
+ ///
+ /// # Examples
+ ///
+ /// ```rust
+ /// # #[macro_use]
+ /// # extern crate serde_json;
+ /// #
+ /// # fn main() {
+ /// use serde_json::map::Entry;
+ ///
+ /// let mut map = serde_json::Map::new();
+ /// map.insert("serde".to_owned(), json!(12));
+ ///
+ /// match map.entry("serde") {
+ /// Entry::Occupied(mut occupied) => {
+ /// assert_eq!(occupied.insert(json!(13)), 12);
+ /// assert_eq!(occupied.get(), 13);
+ /// }
+ /// Entry::Vacant(_) => unimplemented!(),
+ /// }
+ /// # }
+ /// ```
+ #[inline]
+ pub fn insert(&mut self, value: Value) -> Value {
+ self.occupied.insert(value)
+ }
+
+ /// Takes the value of the entry out of the map, and returns it.
+ ///
+ /// # Examples
+ ///
+ /// ```rust
+ /// # #[macro_use]
+ /// # extern crate serde_json;
+ /// #
+ /// # fn main() {
+ /// use serde_json::map::Entry;
+ ///
+ /// let mut map = serde_json::Map::new();
+ /// map.insert("serde".to_owned(), json!(12));
+ ///
+ /// match map.entry("serde") {
+ /// Entry::Occupied(occupied) => {
+ /// assert_eq!(occupied.remove(), 12);
+ /// }
+ /// Entry::Vacant(_) => unimplemented!(),
+ /// }
+ /// # }
+ /// ```
+ #[inline]
+ pub fn remove(self) -> Value {
+ self.occupied.remove()
+ }
+}
+
+//////////////////////////////////////////////////////////////////////////////
+
+impl<'a> IntoIterator for &'a Map<String, Value> {
+ type Item = (&'a String, &'a Value);
+ type IntoIter = Iter<'a>;
+ #[inline]
+ fn into_iter(self) -> Self::IntoIter {
+ Iter {
+ iter: self.map.iter(),
+ }
+ }
+}
+
+/// An iterator over a serde_json::Map's entries.
+pub struct Iter<'a> {
+ iter: IterImpl<'a>,
+}
+
+#[cfg(not(feature = "preserve_order"))]
+type IterImpl<'a> = btree_map::Iter<'a, String, Value>;
+#[cfg(feature = "preserve_order")]
+type IterImpl<'a> = indexmap::map::Iter<'a, String, Value>;
+
+delegate_iterator!((Iter<'a>) => (&'a String, &'a Value));
+
+//////////////////////////////////////////////////////////////////////////////
+
+impl<'a> IntoIterator for &'a mut Map<String, Value> {
+ type Item = (&'a String, &'a mut Value);
+ type IntoIter = IterMut<'a>;
+ #[inline]
+ fn into_iter(self) -> Self::IntoIter {
+ IterMut {
+ iter: self.map.iter_mut(),
+ }
+ }
+}
+
+/// A mutable iterator over a serde_json::Map's entries.
+pub struct IterMut<'a> {
+ iter: IterMutImpl<'a>,
+}
+
+#[cfg(not(feature = "preserve_order"))]
+type IterMutImpl<'a> = btree_map::IterMut<'a, String, Value>;
+#[cfg(feature = "preserve_order")]
+type IterMutImpl<'a> = indexmap::map::IterMut<'a, String, Value>;
+
+delegate_iterator!((IterMut<'a>) => (&'a String, &'a mut Value));
+
+//////////////////////////////////////////////////////////////////////////////
+
+impl IntoIterator for Map<String, Value> {
+ type Item = (String, Value);
+ type IntoIter = IntoIter;
+ #[inline]
+ fn into_iter(self) -> Self::IntoIter {
+ IntoIter {
+ iter: self.map.into_iter(),
+ }
+ }
+}
+
+/// An owning iterator over a serde_json::Map's entries.
+pub struct IntoIter {
+ iter: IntoIterImpl,
+}
+
+#[cfg(not(feature = "preserve_order"))]
+type IntoIterImpl = btree_map::IntoIter<String, Value>;
+#[cfg(feature = "preserve_order")]
+type IntoIterImpl = indexmap::map::IntoIter<String, Value>;
+
+delegate_iterator!((IntoIter) => (String, Value));
+
+//////////////////////////////////////////////////////////////////////////////
+
+/// An iterator over a serde_json::Map's keys.
+pub struct Keys<'a> {
+ iter: KeysImpl<'a>,
+}
+
+#[cfg(not(feature = "preserve_order"))]
+type KeysImpl<'a> = btree_map::Keys<'a, String, Value>;
+#[cfg(feature = "preserve_order")]
+type KeysImpl<'a> = indexmap::map::Keys<'a, String, Value>;
+
+delegate_iterator!((Keys<'a>) => &'a String);
+
+//////////////////////////////////////////////////////////////////////////////
+
+/// An iterator over a serde_json::Map's values.
+pub struct Values<'a> {
+ iter: ValuesImpl<'a>,
+}
+
+#[cfg(not(feature = "preserve_order"))]
+type ValuesImpl<'a> = btree_map::Values<'a, String, Value>;
+#[cfg(feature = "preserve_order")]
+type ValuesImpl<'a> = indexmap::map::Values<'a, String, Value>;
+
+delegate_iterator!((Values<'a>) => &'a Value);
+
+//////////////////////////////////////////////////////////////////////////////
+
+/// A mutable iterator over a serde_json::Map's values.
+pub struct ValuesMut<'a> {
+ iter: ValuesMutImpl<'a>,
+}
+
+#[cfg(not(feature = "preserve_order"))]
+type ValuesMutImpl<'a> = btree_map::ValuesMut<'a, String, Value>;
+#[cfg(feature = "preserve_order")]
+type ValuesMutImpl<'a> = indexmap::map::ValuesMut<'a, String, Value>;
+
+delegate_iterator!((ValuesMut<'a>) => &'a mut Value);
new file mode 100644
--- /dev/null
+++ b/third_party/rust/serde_json/src/number.rs
@@ -0,0 +1,772 @@
+// Copyright 2017 Serde Developers
+//
+// Licensed under the Apache License, Version 2.0 <LICENSE-APACHE or
+// http://www.apache.org/licenses/LICENSE-2.0> or the MIT license
+// <LICENSE-MIT or http://opensource.org/licenses/MIT>, at your
+// option. This file may not be copied, modified, or distributed
+// except according to those terms.
+
+use error::Error;
+use serde::de::{self, Unexpected, Visitor};
+use serde::{Deserialize, Deserializer, Serialize, Serializer};
+use std::fmt::{self, Debug, Display};
+
+#[cfg(feature = "arbitrary_precision")]
+use dtoa;
+#[cfg(feature = "arbitrary_precision")]
+use itoa;
+#[cfg(feature = "arbitrary_precision")]
+use serde::de::{IntoDeserializer, MapAccess};
+
+use de::ParserNumber;
+
+#[cfg(feature = "arbitrary_precision")]
+use error::ErrorCode;
+
+#[cfg(feature = "arbitrary_precision")]
+/// Not public API. Should be pub(crate).
+#[doc(hidden)]
+pub const SERDE_STRUCT_FIELD_NAME: &'static str = "$__serde_private_number";
+
+#[cfg(feature = "arbitrary_precision")]
+/// Not public API. Should be pub(crate).
+#[doc(hidden)]
+pub const SERDE_STRUCT_NAME: &'static str = "$__serde_private_Number";
+
+/// Represents a JSON number, whether integer or floating point.
+#[derive(Clone, PartialEq)]
+pub struct Number {
+ n: N,
+}
+
+#[cfg(not(feature = "arbitrary_precision"))]
+#[derive(Copy, Clone, PartialEq)]
+enum N {
+ PosInt(u64),
+ /// Always less than zero.
+ NegInt(i64),
+ /// Always finite.
+ Float(f64),
+}
+
+#[cfg(feature = "arbitrary_precision")]
+type N = String;
+
+impl Number {
+ /// Returns true if the `Number` is an integer between `i64::MIN` and
+ /// `i64::MAX`.
+ ///
+ /// For any Number on which `is_i64` returns true, `as_i64` is guaranteed to
+ /// return the integer value.
+ ///
+ /// ```rust
+ /// # #[macro_use]
+ /// # extern crate serde_json;
+ /// #
+ /// # fn main() {
+ /// let big = i64::max_value() as u64 + 10;
+ /// let v = json!({ "a": 64, "b": big, "c": 256.0 });
+ ///
+ /// assert!(v["a"].is_i64());
+ ///
+ /// // Greater than i64::MAX.
+ /// assert!(!v["b"].is_i64());
+ ///
+ /// // Numbers with a decimal point are not considered integers.
+ /// assert!(!v["c"].is_i64());
+ /// # }
+ /// ```
+ #[inline]
+ pub fn is_i64(&self) -> bool {
+ #[cfg(not(feature = "arbitrary_precision"))]
+ match self.n {
+ N::PosInt(v) => v <= i64::max_value() as u64,
+ N::NegInt(_) => true,
+ N::Float(_) => false,
+ }
+ #[cfg(feature = "arbitrary_precision")]
+ self.as_i64().is_some()
+ }
+
+ /// Returns true if the `Number` is an integer between zero and `u64::MAX`.
+ ///
+ /// For any Number on which `is_u64` returns true, `as_u64` is guaranteed to
+ /// return the integer value.
+ ///
+ /// ```rust
+ /// # #[macro_use]
+ /// # extern crate serde_json;
+ /// #
+ /// # fn main() {
+ /// let v = json!({ "a": 64, "b": -64, "c": 256.0 });
+ ///
+ /// assert!(v["a"].is_u64());
+ ///
+ /// // Negative integer.
+ /// assert!(!v["b"].is_u64());
+ ///
+ /// // Numbers with a decimal point are not considered integers.
+ /// assert!(!v["c"].is_u64());
+ /// # }
+ /// ```
+ #[inline]
+ pub fn is_u64(&self) -> bool {
+ #[cfg(not(feature = "arbitrary_precision"))]
+ match self.n {
+ N::PosInt(_) => true,
+ N::NegInt(_) | N::Float(_) => false,
+ }
+ #[cfg(feature = "arbitrary_precision")]
+ self.as_u64().is_some()
+ }
+
+ /// Returns true if the `Number` can be represented by f64.
+ ///
+ /// For any Number on which `is_f64` returns true, `as_f64` is guaranteed to
+ /// return the floating point value.
+ ///
+ /// Currently this function returns true if and only if both `is_i64` and
+ /// `is_u64` return false but this is not a guarantee in the future.
+ ///
+ /// ```rust
+ /// # #[macro_use]
+ /// # extern crate serde_json;
+ /// #
+ /// # fn main() {
+ /// let v = json!({ "a": 256.0, "b": 64, "c": -64 });
+ ///
+ /// assert!(v["a"].is_f64());
+ ///
+ /// // Integers.
+ /// assert!(!v["b"].is_f64());
+ /// assert!(!v["c"].is_f64());
+ /// # }
+ /// ```
+ #[inline]
+ pub fn is_f64(&self) -> bool {
+ #[cfg(not(feature = "arbitrary_precision"))]
+ match self.n {
+ N::Float(_) => true,
+ N::PosInt(_) | N::NegInt(_) => false,
+ }
+ #[cfg(feature = "arbitrary_precision")]
+ {
+ for c in self.n.chars() {
+ if c == '.' || c == 'e' || c == 'E' {
+ return self.n.parse::<f64>().ok().map_or(false, |f| f.is_finite());
+ }
+ }
+ false
+ }
+ }
+
+ /// If the `Number` is an integer, represent it as i64 if possible. Returns
+ /// None otherwise.
+ ///
+ /// ```rust
+ /// # #[macro_use]
+ /// # extern crate serde_json;
+ /// #
+ /// # fn main() {
+ /// let big = i64::max_value() as u64 + 10;
+ /// let v = json!({ "a": 64, "b": big, "c": 256.0 });
+ ///
+ /// assert_eq!(v["a"].as_i64(), Some(64));
+ /// assert_eq!(v["b"].as_i64(), None);
+ /// assert_eq!(v["c"].as_i64(), None);
+ /// # }
+ /// ```
+ #[inline]
+ pub fn as_i64(&self) -> Option<i64> {
+ #[cfg(not(feature = "arbitrary_precision"))]
+ match self.n {
+ N::PosInt(n) => if n <= i64::max_value() as u64 {
+ Some(n as i64)
+ } else {
+ None
+ },
+ N::NegInt(n) => Some(n),
+ N::Float(_) => None,
+ }
+ #[cfg(feature = "arbitrary_precision")]
+ self.n.parse().ok()
+ }
+
+ /// If the `Number` is an integer, represent it as u64 if possible. Returns
+ /// None otherwise.
+ ///
+ /// ```rust
+ /// # #[macro_use]
+ /// # extern crate serde_json;
+ /// #
+ /// # fn main() {
+ /// let v = json!({ "a": 64, "b": -64, "c": 256.0 });
+ ///
+ /// assert_eq!(v["a"].as_u64(), Some(64));
+ /// assert_eq!(v["b"].as_u64(), None);
+ /// assert_eq!(v["c"].as_u64(), None);
+ /// # }
+ /// ```
+ #[inline]
+ pub fn as_u64(&self) -> Option<u64> {
+ #[cfg(not(feature = "arbitrary_precision"))]
+ match self.n {
+ N::PosInt(n) => Some(n),
+ N::NegInt(_) | N::Float(_) => None,
+ }
+ #[cfg(feature = "arbitrary_precision")]
+ self.n.parse().ok()
+ }
+
+ /// Represents the number as f64 if possible. Returns None otherwise.
+ ///
+ /// ```rust
+ /// # #[macro_use]
+ /// # extern crate serde_json;
+ /// #
+ /// # fn main() {
+ /// let v = json!({ "a": 256.0, "b": 64, "c": -64 });
+ ///
+ /// assert_eq!(v["a"].as_f64(), Some(256.0));
+ /// assert_eq!(v["b"].as_f64(), Some(64.0));
+ /// assert_eq!(v["c"].as_f64(), Some(-64.0));
+ /// # }
+ /// ```
+ #[inline]
+ pub fn as_f64(&self) -> Option<f64> {
+ #[cfg(not(feature = "arbitrary_precision"))]
+ match self.n {
+ N::PosInt(n) => Some(n as f64),
+ N::NegInt(n) => Some(n as f64),
+ N::Float(n) => Some(n),
+ }
+ #[cfg(feature = "arbitrary_precision")]
+ self.n.parse().ok()
+ }
+
+ /// Converts a finite `f64` to a `Number`. Infinite or NaN values are not JSON
+ /// numbers.
+ ///
+ /// ```rust
+ /// # use std::f64;
+ /// #
+ /// # use serde_json::Number;
+ /// #
+ /// assert!(Number::from_f64(256.0).is_some());
+ ///
+ /// assert!(Number::from_f64(f64::NAN).is_none());
+ /// ```
+ #[inline]
+ pub fn from_f64(f: f64) -> Option<Number> {
+ if f.is_finite() {
+ let n = {
+ #[cfg(not(feature = "arbitrary_precision"))]
+ {
+ N::Float(f)
+ }
+ #[cfg(feature = "arbitrary_precision")]
+ {
+ let mut buf = Vec::new();
+ dtoa::write(&mut buf, f).unwrap();
+ String::from_utf8(buf).unwrap()
+ }
+ };
+ Some(Number { n: n })
+ } else {
+ None
+ }
+ }
+
+ #[cfg(feature = "arbitrary_precision")]
+ /// Not public API. Only tests use this.
+ #[doc(hidden)]
+ #[inline]
+ pub fn from_string_unchecked(n: String) -> Self {
+ Number { n: n }
+ }
+}
+
+impl fmt::Display for Number {
+ #[cfg(not(feature = "arbitrary_precision"))]
+ fn fmt(&self, formatter: &mut fmt::Formatter) -> fmt::Result {
+ match self.n {
+ N::PosInt(u) => Display::fmt(&u, formatter),
+ N::NegInt(i) => Display::fmt(&i, formatter),
+ N::Float(f) => Display::fmt(&f, formatter),
+ }
+ }
+
+ #[cfg(feature = "arbitrary_precision")]
+ fn fmt(&self, formatter: &mut fmt::Formatter) -> fmt::Result {
+ Display::fmt(&self.n, formatter)
+ }
+}
+
+impl Debug for Number {
+ #[cfg(not(feature = "arbitrary_precision"))]
+ fn fmt(&self, formatter: &mut fmt::Formatter) -> fmt::Result {
+ let mut debug = formatter.debug_tuple("Number");
+ match self.n {
+ N::PosInt(i) => {
+ debug.field(&i);
+ }
+ N::NegInt(i) => {
+ debug.field(&i);
+ }
+ N::Float(f) => {
+ debug.field(&f);
+ }
+ }
+ debug.finish()
+ }
+
+ #[cfg(feature = "arbitrary_precision")]
+ fn fmt(&self, formatter: &mut fmt::Formatter) -> fmt::Result {
+ write!(formatter, "Number({})", &self.n)
+ }
+}
+
+impl Serialize for Number {
+ #[cfg(not(feature = "arbitrary_precision"))]
+ #[inline]
+ fn serialize<S>(&self, serializer: S) -> Result<S::Ok, S::Error>
+ where
+ S: Serializer,
+ {
+ match self.n {
+ N::PosInt(u) => serializer.serialize_u64(u),
+ N::NegInt(i) => serializer.serialize_i64(i),
+ N::Float(f) => serializer.serialize_f64(f),
+ }
+ }
+
+ #[cfg(feature = "arbitrary_precision")]
+ #[inline]
+ fn serialize<S>(&self, serializer: S) -> Result<S::Ok, S::Error>
+ where
+ S: Serializer,
+ {
+ use serde::ser::SerializeStruct;
+
+ let mut s = serializer.serialize_struct(SERDE_STRUCT_NAME, 1)?;
+ s.serialize_field(SERDE_STRUCT_FIELD_NAME, &self.n)?;
+ s.end()
+ }
+}
+
+impl<'de> Deserialize<'de> for Number {
+ #[inline]
+ fn deserialize<D>(deserializer: D) -> Result<Number, D::Error>
+ where
+ D: Deserializer<'de>,
+ {
+ struct NumberVisitor;
+
+ impl<'de> Visitor<'de> for NumberVisitor {
+ type Value = Number;
+
+ fn expecting(&self, formatter: &mut fmt::Formatter) -> fmt::Result {
+ formatter.write_str("a JSON number")
+ }
+
+ #[inline]
+ fn visit_i64<E>(self, value: i64) -> Result<Number, E> {
+ Ok(value.into())
+ }
+
+ #[inline]
+ fn visit_u64<E>(self, value: u64) -> Result<Number, E> {
+ Ok(value.into())
+ }
+
+ #[inline]
+ fn visit_f64<E>(self, value: f64) -> Result<Number, E>
+ where
+ E: de::Error,
+ {
+ Number::from_f64(value).ok_or_else(|| de::Error::custom("not a JSON number"))
+ }
+
+ #[cfg(feature = "arbitrary_precision")]
+ #[inline]
+ fn visit_map<V>(self, mut visitor: V) -> Result<Number, V::Error>
+ where
+ V: de::MapAccess<'de>,
+ {
+ let value = visitor.next_key::<NumberKey>()?;
+ if value.is_none() {
+ return Err(de::Error::invalid_type(Unexpected::Map, &self));
+ }
+ let v: NumberFromString = visitor.next_value()?;
+ Ok(v.value)
+ }
+ }
+
+ deserializer.deserialize_any(NumberVisitor)
+ }
+}
+
+#[cfg(feature = "arbitrary_precision")]
+struct NumberKey;
+
+#[cfg(feature = "arbitrary_precision")]
+impl<'de> de::Deserialize<'de> for NumberKey {
+ fn deserialize<D>(deserializer: D) -> Result<NumberKey, D::Error>
+ where
+ D: de::Deserializer<'de>,
+ {
+ struct FieldVisitor;
+
+ impl<'de> de::Visitor<'de> for FieldVisitor {
+ type Value = ();
+
+ fn expecting(&self, formatter: &mut fmt::Formatter) -> fmt::Result {
+ formatter.write_str("a valid number field")
+ }
+
+ fn visit_str<E>(self, s: &str) -> Result<(), E>
+ where
+ E: de::Error,
+ {
+ if s == SERDE_STRUCT_FIELD_NAME {
+ Ok(())
+ } else {
+ Err(de::Error::custom("expected field with custom name"))
+ }
+ }
+ }
+
+ deserializer.deserialize_identifier(FieldVisitor)?;
+ Ok(NumberKey)
+ }
+}
+
+#[cfg(feature = "arbitrary_precision")]
+pub struct NumberFromString {
+ pub value: Number,
+}
+
+#[cfg(feature = "arbitrary_precision")]
+impl<'de> de::Deserialize<'de> for NumberFromString {
+ fn deserialize<D>(deserializer: D) -> Result<NumberFromString, D::Error>
+ where
+ D: de::Deserializer<'de>,
+ {
+ struct Visitor;
+
+ impl<'de> de::Visitor<'de> for Visitor {
+ type Value = NumberFromString;
+
+ fn expecting(&self, formatter: &mut fmt::Formatter) -> fmt::Result {
+ formatter.write_str("string containing a number")
+ }
+
+ fn visit_str<E>(self, s: &str) -> Result<NumberFromString, E>
+ where
+ E: de::Error,
+ {
+ let n = try!(s.parse().map_err(de::Error::custom));
+ Ok(NumberFromString { value: n })
+ }
+ }
+
+ deserializer.deserialize_str(Visitor)
+ }
+}
+
+#[cfg(feature = "arbitrary_precision")]
+fn invalid_number() -> Error {
+ Error::syntax(ErrorCode::InvalidNumber, 0, 0)
+}
+
+macro_rules! deserialize_any {
+ (@expand [$($num_string:tt)*]) => {
+ #[cfg(not(feature = "arbitrary_precision"))]
+ #[inline]
+ fn deserialize_any<V>(self, visitor: V) -> Result<V::Value, Error>
+ where
+ V: Visitor<'de>,
+ {
+ match self.n {
+ N::PosInt(u) => visitor.visit_u64(u),
+ N::NegInt(i) => visitor.visit_i64(i),
+ N::Float(f) => visitor.visit_f64(f),
+ }
+ }
+
+ #[cfg(feature = "arbitrary_precision")]
+ #[inline]
+ fn deserialize_any<V>(self, visitor: V) -> Result<V::Value, Error>
+ where V: Visitor<'de>
+ {
+ if let Some(u) = self.as_u64() {
+ return visitor.visit_u64(u);
+ } else if let Some(i) = self.as_i64() {
+ return visitor.visit_i64(i);
+ } else if let Some(f) = self.as_f64() {
+ if f.to_string() == self.n {
+ return visitor.visit_f64(f);
+ }
+ }
+
+ visitor.visit_map(NumberDeserializer {
+ number: Some(self.$($num_string)*),
+ })
+ }
+ };
+
+ (owned) => {
+ deserialize_any!(@expand [n]);
+ };
+
+ (ref) => {
+ deserialize_any!(@expand [n.clone()]);
+ };
+}
+
+macro_rules! deserialize_number {
+ ($deserialize:ident => $visit:ident) => {
+ #[cfg(not(feature = "arbitrary_precision"))]
+ fn $deserialize<V>(self, visitor: V) -> Result<V::Value, Error>
+ where
+ V: Visitor<'de>,
+ {
+ self.deserialize_any(visitor)
+ }
+
+ #[cfg(feature = "arbitrary_precision")]
+ fn $deserialize<V>(self, visitor: V) -> Result<V::Value, Error>
+ where
+ V: de::Visitor<'de>,
+ {
+ visitor.$visit(self.n.parse().map_err(|_| invalid_number())?)
+ }
+ }
+}
+
+impl<'de> Deserializer<'de> for Number {
+ type Error = Error;
+
+ deserialize_any!(owned);
+
+ deserialize_number!(deserialize_i8 => visit_i8);
+ deserialize_number!(deserialize_i16 => visit_i16);
+ deserialize_number!(deserialize_i32 => visit_i32);
+ deserialize_number!(deserialize_i64 => visit_i64);
+ deserialize_number!(deserialize_u8 => visit_u8);
+ deserialize_number!(deserialize_u16 => visit_u16);
+ deserialize_number!(deserialize_u32 => visit_u32);
+ deserialize_number!(deserialize_u64 => visit_u64);
+ deserialize_number!(deserialize_f32 => visit_f32);
+ deserialize_number!(deserialize_f64 => visit_f64);
+
+ serde_if_integer128! {
+ deserialize_number!(deserialize_i128 => visit_i128);
+ deserialize_number!(deserialize_u128 => visit_u128);
+ }
+
+ forward_to_deserialize_any! {
+ bool char str string bytes byte_buf option unit unit_struct
+ newtype_struct seq tuple tuple_struct map struct enum identifier
+ ignored_any
+ }
+}
+
+impl<'de, 'a> Deserializer<'de> for &'a Number {
+ type Error = Error;
+
+ deserialize_any!(ref);
+
+ deserialize_number!(deserialize_i8 => visit_i8);
+ deserialize_number!(deserialize_i16 => visit_i16);
+ deserialize_number!(deserialize_i32 => visit_i32);
+ deserialize_number!(deserialize_i64 => visit_i64);
+ deserialize_number!(deserialize_u8 => visit_u8);
+ deserialize_number!(deserialize_u16 => visit_u16);
+ deserialize_number!(deserialize_u32 => visit_u32);
+ deserialize_number!(deserialize_u64 => visit_u64);
+ deserialize_number!(deserialize_f32 => visit_f32);
+ deserialize_number!(deserialize_f64 => visit_f64);
+
+ serde_if_integer128! {
+ deserialize_number!(deserialize_i128 => visit_i128);
+ deserialize_number!(deserialize_u128 => visit_u128);
+ }
+
+ forward_to_deserialize_any! {
+ bool char str string bytes byte_buf option unit unit_struct
+ newtype_struct seq tuple tuple_struct map struct enum identifier
+ ignored_any
+ }
+}
+
+#[cfg(feature = "arbitrary_precision")]
+// Not public API. Should be pub(crate).
+#[doc(hidden)]
+pub struct NumberDeserializer {
+ pub number: Option<String>,
+}
+
+#[cfg(feature = "arbitrary_precision")]
+impl<'de> MapAccess<'de> for NumberDeserializer {
+ type Error = Error;
+
+ fn next_key_seed<K>(&mut self, seed: K) -> Result<Option<K::Value>, Error>
+ where
+ K: de::DeserializeSeed<'de>,
+ {
+ if self.number.is_none() {
+ return Ok(None);
+ }
+ seed.deserialize(NumberFieldDeserializer).map(Some)
+ }
+
+ fn next_value_seed<V>(&mut self, seed: V) -> Result<V::Value, Error>
+ where
+ V: de::DeserializeSeed<'de>,
+ {
+ seed.deserialize(self.number.take().unwrap().into_deserializer())
+ }
+}
+
+#[cfg(feature = "arbitrary_precision")]
+struct NumberFieldDeserializer;
+
+#[cfg(feature = "arbitrary_precision")]
+impl<'de> Deserializer<'de> for NumberFieldDeserializer {
+ type Error = Error;
+
+ fn deserialize_any<V>(self, visitor: V) -> Result<V::Value, Error>
+ where
+ V: de::Visitor<'de>,
+ {
+ visitor.visit_borrowed_str(SERDE_STRUCT_FIELD_NAME)
+ }
+
+ forward_to_deserialize_any! {
+ bool u8 u16 u32 u64 u128 i8 i16 i32 i64 i128 f32 f64 char str string seq
+ bytes byte_buf map struct option unit newtype_struct ignored_any
+ unit_struct tuple_struct tuple enum identifier
+ }
+}
+
+impl From<ParserNumber> for Number {
+ fn from(value: ParserNumber) -> Self {
+ let n = match value {
+ ParserNumber::F64(f) => {
+ #[cfg(not(feature = "arbitrary_precision"))]
+ {
+ N::Float(f)
+ }
+ #[cfg(feature = "arbitrary_precision")]
+ {
+ f.to_string()
+ }
+ }
+ ParserNumber::U64(u) => {
+ #[cfg(not(feature = "arbitrary_precision"))]
+ {
+ N::PosInt(u)
+ }
+ #[cfg(feature = "arbitrary_precision")]
+ {
+ u.to_string()
+ }
+ }
+ ParserNumber::I64(i) => {
+ #[cfg(not(feature = "arbitrary_precision"))]
+ {
+ N::NegInt(i)
+ }
+ #[cfg(feature = "arbitrary_precision")]
+ {
+ i.to_string()
+ }
+ }
+ #[cfg(feature = "arbitrary_precision")]
+ ParserNumber::String(s) => s,
+ };
+ Number { n: n }
+ }
+}
+
+macro_rules! impl_from_unsigned {
+ (
+ $($ty:ty),*
+ ) => {
+ $(
+ impl From<$ty> for Number {
+ #[inline]
+ fn from(u: $ty) -> Self {
+ let n = {
+ #[cfg(not(feature = "arbitrary_precision"))]
+ { N::PosInt(u as u64) }
+ #[cfg(feature = "arbitrary_precision")]
+ {
+ let mut buf = Vec::new();
+ itoa::write(&mut buf, u).unwrap();
+ String::from_utf8(buf).unwrap()
+ }
+ };
+ Number { n: n }
+ }
+ }
+ )*
+ };
+}
+
+macro_rules! impl_from_signed {
+ (
+ $($ty:ty),*
+ ) => {
+ $(
+ impl From<$ty> for Number {
+ #[inline]
+ fn from(i: $ty) -> Self {
+ let n = {
+ #[cfg(not(feature = "arbitrary_precision"))]
+ {
+ if i < 0 {
+ N::NegInt(i as i64)
+ } else {
+ N::PosInt(i as u64)
+ }
+ }
+ #[cfg(feature = "arbitrary_precision")]
+ {
+ let mut buf = Vec::new();
+ itoa::write(&mut buf, i).unwrap();
+ String::from_utf8(buf).unwrap()
+ }
+ };
+ Number { n: n }
+ }
+ }
+ )*
+ };
+}
+
+impl_from_unsigned!(u8, u16, u32, u64, usize);
+impl_from_signed!(i8, i16, i32, i64, isize);
+
+impl Number {
+ #[cfg(not(feature = "arbitrary_precision"))]
+ // Not public API. Should be pub(crate).
+ #[doc(hidden)]
+ #[cold]
+ pub fn unexpected(&self) -> Unexpected {
+ match self.n {
+ N::PosInt(u) => Unexpected::Unsigned(u),
+ N::NegInt(i) => Unexpected::Signed(i),
+ N::Float(f) => Unexpected::Float(f),
+ }
+ }
+
+ #[cfg(feature = "arbitrary_precision")]
+ // Not public API. Should be pub(crate).
+ #[doc(hidden)]
+ #[cold]
+ pub fn unexpected(&self) -> Unexpected {
+ Unexpected::Other("number")
+ }
+}
new file mode 100644
--- /dev/null
+++ b/third_party/rust/serde_json/src/read.rs
@@ -0,0 +1,677 @@
+// Copyright 2017 Serde Developers
+//
+// Licensed under the Apache License, Version 2.0 <LICENSE-APACHE or
+// http://www.apache.org/licenses/LICENSE-2.0> or the MIT license
+// <LICENSE-MIT or http://opensource.org/licenses/MIT>, at your
+// option. This file may not be copied, modified, or distributed
+// except according to those terms.
+
+use std::ops::Deref;
+use std::{char, cmp, io, str};
+
+use iter::LineColIterator;
+
+use super::error::{Error, ErrorCode, Result};
+
+/// Trait used by the deserializer for iterating over input. This is manually
+/// "specialized" for iterating over &[u8]. Once feature(specialization) is
+/// stable we can use actual specialization.
+///
+/// This trait is sealed and cannot be implemented for types outside of
+/// `serde_json`.
+pub trait Read<'de>: private::Sealed {
+ #[doc(hidden)]
+ fn next(&mut self) -> io::Result<Option<u8>>;
+ #[doc(hidden)]
+ fn peek(&mut self) -> io::Result<Option<u8>>;
+
+ /// Only valid after a call to peek(). Discards the peeked byte.
+ #[doc(hidden)]
+ fn discard(&mut self);
+
+ /// Position of the most recent call to next().
+ ///
+ /// The most recent call was probably next() and not peek(), but this method
+ /// should try to return a sensible result if the most recent call was
+ /// actually peek() because we don't always know.
+ ///
+ /// Only called in case of an error, so performance is not important.
+ #[doc(hidden)]
+ fn position(&self) -> Position;
+
+ /// Position of the most recent call to peek().
+ ///
+ /// The most recent call was probably peek() and not next(), but this method
+ /// should try to return a sensible result if the most recent call was
+ /// actually next() because we don't always know.
+ ///
+ /// Only called in case of an error, so performance is not important.
+ #[doc(hidden)]
+ fn peek_position(&self) -> Position;
+
+ /// Offset from the beginning of the input to the next byte that would be
+ /// returned by next() or peek().
+ #[doc(hidden)]
+ fn byte_offset(&self) -> usize;
+
+ /// Assumes the previous byte was a quotation mark. Parses a JSON-escaped
+ /// string until the next quotation mark using the given scratch space if
+ /// necessary. The scratch space is initially empty.
+ #[doc(hidden)]
+ fn parse_str<'s>(&'s mut self, scratch: &'s mut Vec<u8>) -> Result<Reference<'de, 's, str>>;
+
+ /// Assumes the previous byte was a quotation mark. Parses a JSON-escaped
+ /// string until the next quotation mark using the given scratch space if
+ /// necessary. The scratch space is initially empty.
+ ///
+ /// This function returns the raw bytes in the string with escape sequences
+ /// expanded but without performing unicode validation.
+ #[doc(hidden)]
+ fn parse_str_raw<'s>(
+ &'s mut self,
+ scratch: &'s mut Vec<u8>,
+ ) -> Result<Reference<'de, 's, [u8]>>;
+
+ /// Assumes the previous byte was a quotation mark. Parses a JSON-escaped
+ /// string until the next quotation mark but discards the data.
+ #[doc(hidden)]
+ fn ignore_str(&mut self) -> Result<()>;
+}
+
+pub struct Position {
+ pub line: usize,
+ pub column: usize,
+}
+
+pub enum Reference<'b, 'c, T: ?Sized + 'static> {
+ Borrowed(&'b T),
+ Copied(&'c T),
+}
+
+impl<'b, 'c, T: ?Sized + 'static> Deref for Reference<'b, 'c, T> {
+ type Target = T;
+
+ fn deref(&self) -> &Self::Target {
+ match *self {
+ Reference::Borrowed(b) => b,
+ Reference::Copied(c) => c,
+ }
+ }
+}
+
+/// JSON input source that reads from a std::io input stream.
+pub struct IoRead<R>
+where
+ R: io::Read,
+{
+ iter: LineColIterator<io::Bytes<R>>,
+ /// Temporary storage of peeked byte.
+ ch: Option<u8>,
+}
+
+/// JSON input source that reads from a slice of bytes.
+//
+// This is more efficient than other iterators because peek() can be read-only
+// and we can compute line/col position only if an error happens.
+pub struct SliceRead<'a> {
+ slice: &'a [u8],
+ /// Index of the *next* byte that will be returned by next() or peek().
+ index: usize,
+}
+
+/// JSON input source that reads from a UTF-8 string.
+//
+// Able to elide UTF-8 checks by assuming that the input is valid UTF-8.
+pub struct StrRead<'a> {
+ delegate: SliceRead<'a>,
+}
+
+// Prevent users from implementing the Read trait.
+mod private {
+ pub trait Sealed {}
+}
+
+//////////////////////////////////////////////////////////////////////////////
+
+impl<R> IoRead<R>
+where
+ R: io::Read,
+{
+ /// Create a JSON input source to read from a std::io input stream.
+ pub fn new(reader: R) -> Self {
+ IoRead {
+ iter: LineColIterator::new(reader.bytes()),
+ ch: None,
+ }
+ }
+}
+
+impl<R> private::Sealed for IoRead<R> where R: io::Read {}
+
+impl<R> IoRead<R>
+where
+ R: io::Read,
+{
+ fn parse_str_bytes<'s, T, F>(
+ &'s mut self,
+ scratch: &'s mut Vec<u8>,
+ validate: bool,
+ result: F,
+ ) -> Result<T>
+ where
+ T: 's,
+ F: FnOnce(&'s Self, &'s [u8]) -> Result<T>,
+ {
+ loop {
+ let ch = try!(next_or_eof(self));
+ if !ESCAPE[ch as usize] {
+ scratch.push(ch);
+ continue;
+ }
+ match ch {
+ b'"' => {
+ return result(self, scratch);
+ }
+ b'\\' => {
+ try!(parse_escape(self, scratch));
+ }
+ _ => {
+ if validate {
+ return error(self, ErrorCode::ControlCharacterWhileParsingString);
+ }
+ scratch.push(ch);
+ }
+ }
+ }
+ }
+}
+
+impl<'de, R> Read<'de> for IoRead<R>
+where
+ R: io::Read,
+{
+ #[inline]
+ fn next(&mut self) -> io::Result<Option<u8>> {
+ match self.ch.take() {
+ Some(ch) => Ok(Some(ch)),
+ None => match self.iter.next() {
+ Some(Err(err)) => Err(err),
+ Some(Ok(ch)) => Ok(Some(ch)),
+ None => Ok(None),
+ },
+ }
+ }
+
+ #[inline]
+ fn peek(&mut self) -> io::Result<Option<u8>> {
+ match self.ch {
+ Some(ch) => Ok(Some(ch)),
+ None => match self.iter.next() {
+ Some(Err(err)) => Err(err),
+ Some(Ok(ch)) => {
+ self.ch = Some(ch);
+ Ok(self.ch)
+ }
+ None => Ok(None),
+ },
+ }
+ }
+
+ #[inline]
+ fn discard(&mut self) {
+ self.ch = None;
+ }
+
+ fn position(&self) -> Position {
+ Position {
+ line: self.iter.line(),
+ column: self.iter.col(),
+ }
+ }
+
+ fn peek_position(&self) -> Position {
+ // The LineColIterator updates its position during peek() so it has the
+ // right one here.
+ self.position()
+ }
+
+ fn byte_offset(&self) -> usize {
+ match self.ch {
+ Some(_) => self.iter.byte_offset() - 1,
+ None => self.iter.byte_offset(),
+ }
+ }
+
+ fn parse_str<'s>(&'s mut self, scratch: &'s mut Vec<u8>) -> Result<Reference<'de, 's, str>> {
+ self.parse_str_bytes(scratch, true, as_str)
+ .map(Reference::Copied)
+ }
+
+ fn parse_str_raw<'s>(
+ &'s mut self,
+ scratch: &'s mut Vec<u8>,
+ ) -> Result<Reference<'de, 's, [u8]>> {
+ self.parse_str_bytes(scratch, false, |_, bytes| Ok(bytes))
+ .map(Reference::Copied)
+ }
+
+ fn ignore_str(&mut self) -> Result<()> {
+ loop {
+ let ch = try!(next_or_eof(self));
+ if !ESCAPE[ch as usize] {
+ continue;
+ }
+ match ch {
+ b'"' => {
+ return Ok(());
+ }
+ b'\\' => {
+ try!(ignore_escape(self));
+ }
+ _ => {
+ return error(self, ErrorCode::ControlCharacterWhileParsingString);
+ }
+ }
+ }
+ }
+}
+
+//////////////////////////////////////////////////////////////////////////////
+
+impl<'a> SliceRead<'a> {
+ /// Create a JSON input source to read from a slice of bytes.
+ pub fn new(slice: &'a [u8]) -> Self {
+ SliceRead {
+ slice: slice,
+ index: 0,
+ }
+ }
+
+ fn position_of_index(&self, i: usize) -> Position {
+ let mut position = Position { line: 1, column: 0 };
+ for ch in &self.slice[..i] {
+ match *ch {
+ b'\n' => {
+ position.line += 1;
+ position.column = 0;
+ }
+ _ => {
+ position.column += 1;
+ }
+ }
+ }
+ position
+ }
+
+ /// The big optimization here over IoRead is that if the string contains no
+ /// backslash escape sequences, the returned &str is a slice of the raw JSON
+ /// data so we avoid copying into the scratch space.
+ fn parse_str_bytes<'s, T: ?Sized, F>(
+ &'s mut self,
+ scratch: &'s mut Vec<u8>,
+ validate: bool,
+ result: F,
+ ) -> Result<Reference<'a, 's, T>>
+ where
+ T: 's,
+ F: for<'f> FnOnce(&'s Self, &'f [u8]) -> Result<&'f T>,
+ {
+ // Index of the first byte not yet copied into the scratch space.
+ let mut start = self.index;
+
+ loop {
+ while self.index < self.slice.len() && !ESCAPE[self.slice[self.index] as usize] {
+ self.index += 1;
+ }
+ if self.index == self.slice.len() {
+ return error(self, ErrorCode::EofWhileParsingString);
+ }
+ match self.slice[self.index] {
+ b'"' => {
+ if scratch.is_empty() {
+ // Fast path: return a slice of the raw JSON without any
+ // copying.
+ let borrowed = &self.slice[start..self.index];
+ self.index += 1;
+ return result(self, borrowed).map(Reference::Borrowed);
+ } else {
+ scratch.extend_from_slice(&self.slice[start..self.index]);
+ self.index += 1;
+ return result(self, scratch).map(Reference::Copied);
+ }
+ }
+ b'\\' => {
+ scratch.extend_from_slice(&self.slice[start..self.index]);
+ self.index += 1;
+ try!(parse_escape(self, scratch));
+ start = self.index;
+ }
+ _ => {
+ if validate {
+ return error(self, ErrorCode::ControlCharacterWhileParsingString);
+ }
+ self.index += 1;
+ }
+ }
+ }
+ }
+}
+
+impl<'a> private::Sealed for SliceRead<'a> {}
+
+impl<'a> Read<'a> for SliceRead<'a> {
+ #[inline]
+ fn next(&mut self) -> io::Result<Option<u8>> {
+ // `Ok(self.slice.get(self.index).map(|ch| { self.index += 1; *ch }))`
+ // is about 10% slower.
+ Ok(if self.index < self.slice.len() {
+ let ch = self.slice[self.index];
+ self.index += 1;
+ Some(ch)
+ } else {
+ None
+ })
+ }
+
+ #[inline]
+ fn peek(&mut self) -> io::Result<Option<u8>> {
+ // `Ok(self.slice.get(self.index).map(|ch| *ch))` is about 10% slower
+ // for some reason.
+ Ok(if self.index < self.slice.len() {
+ Some(self.slice[self.index])
+ } else {
+ None
+ })
+ }
+
+ #[inline]
+ fn discard(&mut self) {
+ self.index += 1;
+ }
+
+ fn position(&self) -> Position {
+ self.position_of_index(self.index)
+ }
+
+ fn peek_position(&self) -> Position {
+ // Cap it at slice.len() just in case the most recent call was next()
+ // and it returned the last byte.
+ self.position_of_index(cmp::min(self.slice.len(), self.index + 1))
+ }
+
+ fn byte_offset(&self) -> usize {
+ self.index
+ }
+
+ fn parse_str<'s>(&'s mut self, scratch: &'s mut Vec<u8>) -> Result<Reference<'a, 's, str>> {
+ self.parse_str_bytes(scratch, true, as_str)
+ }
+
+ fn parse_str_raw<'s>(
+ &'s mut self,
+ scratch: &'s mut Vec<u8>,
+ ) -> Result<Reference<'a, 's, [u8]>> {
+ self.parse_str_bytes(scratch, false, |_, bytes| Ok(bytes))
+ }
+
+ fn ignore_str(&mut self) -> Result<()> {
+ loop {
+ while self.index < self.slice.len() && !ESCAPE[self.slice[self.index] as usize] {
+ self.index += 1;
+ }
+ if self.index == self.slice.len() {
+ return error(self, ErrorCode::EofWhileParsingString);
+ }
+ match self.slice[self.index] {
+ b'"' => {
+ self.index += 1;
+ return Ok(());
+ }
+ b'\\' => {
+ self.index += 1;
+ try!(ignore_escape(self));
+ }
+ _ => {
+ return error(self, ErrorCode::ControlCharacterWhileParsingString);
+ }
+ }
+ }
+ }
+}
+
+//////////////////////////////////////////////////////////////////////////////
+
+impl<'a> StrRead<'a> {
+ /// Create a JSON input source to read from a UTF-8 string.
+ pub fn new(s: &'a str) -> Self {
+ StrRead {
+ delegate: SliceRead::new(s.as_bytes()),
+ }
+ }
+}
+
+impl<'a> private::Sealed for StrRead<'a> {}
+
+impl<'a> Read<'a> for StrRead<'a> {
+ #[inline]
+ fn next(&mut self) -> io::Result<Option<u8>> {
+ self.delegate.next()
+ }
+
+ #[inline]
+ fn peek(&mut self) -> io::Result<Option<u8>> {
+ self.delegate.peek()
+ }
+
+ #[inline]
+ fn discard(&mut self) {
+ self.delegate.discard();
+ }
+
+ fn position(&self) -> Position {
+ self.delegate.position()
+ }
+
+ fn peek_position(&self) -> Position {
+ self.delegate.peek_position()
+ }
+
+ fn byte_offset(&self) -> usize {
+ self.delegate.byte_offset()
+ }
+
+ fn parse_str<'s>(&'s mut self, scratch: &'s mut Vec<u8>) -> Result<Reference<'a, 's, str>> {
+ self.delegate.parse_str_bytes(scratch, true, |_, bytes| {
+ // The input is assumed to be valid UTF-8 and the \u-escapes are
+ // checked along the way, so don't need to check here.
+ Ok(unsafe { str::from_utf8_unchecked(bytes) })
+ })
+ }
+
+ fn parse_str_raw<'s>(
+ &'s mut self,
+ scratch: &'s mut Vec<u8>,
+ ) -> Result<Reference<'a, 's, [u8]>> {
+ self.delegate.parse_str_raw(scratch)
+ }
+
+ fn ignore_str(&mut self) -> Result<()> {
+ self.delegate.ignore_str()
+ }
+}
+
+//////////////////////////////////////////////////////////////////////////////
+
+const CT: bool = true; // control character \x00...\x1F
+const QU: bool = true; // quote \x22
+const BS: bool = true; // backslash \x5C
+const O: bool = false; // allow unescaped
+
+// Lookup table of bytes that must be escaped. A value of true at index i means
+// that byte i requires an escape sequence in the input.
+#[cfg_attr(rustfmt, rustfmt_skip)]
+static ESCAPE: [bool; 256] = [
+ // 1 2 3 4 5 6 7 8 9 A B C D E F
+ CT, CT, CT, CT, CT, CT, CT, CT, CT, CT, CT, CT, CT, CT, CT, CT, // 0
+ CT, CT, CT, CT, CT, CT, CT, CT, CT, CT, CT, CT, CT, CT, CT, CT, // 1
+ O, O, QU, O, O, O, O, O, O, O, O, O, O, O, O, O, // 2
+ O, O, O, O, O, O, O, O, O, O, O, O, O, O, O, O, // 3
+ O, O, O, O, O, O, O, O, O, O, O, O, O, O, O, O, // 4
+ O, O, O, O, O, O, O, O, O, O, O, O, BS, O, O, O, // 5
+ O, O, O, O, O, O, O, O, O, O, O, O, O, O, O, O, // 6
+ O, O, O, O, O, O, O, O, O, O, O, O, O, O, O, O, // 7
+ O, O, O, O, O, O, O, O, O, O, O, O, O, O, O, O, // 8
+ O, O, O, O, O, O, O, O, O, O, O, O, O, O, O, O, // 9
+ O, O, O, O, O, O, O, O, O, O, O, O, O, O, O, O, // A
+ O, O, O, O, O, O, O, O, O, O, O, O, O, O, O, O, // B
+ O, O, O, O, O, O, O, O, O, O, O, O, O, O, O, O, // C
+ O, O, O, O, O, O, O, O, O, O, O, O, O, O, O, O, // D
+ O, O, O, O, O, O, O, O, O, O, O, O, O, O, O, O, // E
+ O, O, O, O, O, O, O, O, O, O, O, O, O, O, O, O, // F
+];
+
+fn next_or_eof<'de, R: ?Sized + Read<'de>>(read: &mut R) -> Result<u8> {
+ match try!(read.next().map_err(Error::io)) {
+ Some(b) => Ok(b),
+ None => error(read, ErrorCode::EofWhileParsingString),
+ }
+}
+
+fn error<'de, R: ?Sized + Read<'de>, T>(read: &R, reason: ErrorCode) -> Result<T> {
+ let position = read.position();
+ Err(Error::syntax(reason, position.line, position.column))
+}
+
+fn as_str<'de, 's, R: Read<'de>>(read: &R, slice: &'s [u8]) -> Result<&'s str> {
+ str::from_utf8(slice).or_else(|_| error(read, ErrorCode::InvalidUnicodeCodePoint))
+}
+
+/// Parses a JSON escape sequence and appends it into the scratch space. Assumes
+/// the previous byte read was a backslash.
+fn parse_escape<'de, R: Read<'de>>(read: &mut R, scratch: &mut Vec<u8>) -> Result<()> {
+ let ch = try!(next_or_eof(read));
+
+ match ch {
+ b'"' => scratch.push(b'"'),
+ b'\\' => scratch.push(b'\\'),
+ b'/' => scratch.push(b'/'),
+ b'b' => scratch.push(b'\x08'),
+ b'f' => scratch.push(b'\x0c'),
+ b'n' => scratch.push(b'\n'),
+ b'r' => scratch.push(b'\r'),
+ b't' => scratch.push(b'\t'),
+ b'u' => {
+ let c = match try!(decode_hex_escape(read)) {
+ 0xDC00...0xDFFF => {
+ return error(read, ErrorCode::LoneLeadingSurrogateInHexEscape);
+ }
+
+ // Non-BMP characters are encoded as a sequence of
+ // two hex escapes, representing UTF-16 surrogates.
+ n1 @ 0xD800...0xDBFF => {
+ if try!(next_or_eof(read)) != b'\\' {
+ return error(read, ErrorCode::UnexpectedEndOfHexEscape);
+ }
+ if try!(next_or_eof(read)) != b'u' {
+ return error(read, ErrorCode::UnexpectedEndOfHexEscape);
+ }
+
+ let n2 = try!(decode_hex_escape(read));
+
+ if n2 < 0xDC00 || n2 > 0xDFFF {
+ return error(read, ErrorCode::LoneLeadingSurrogateInHexEscape);
+ }
+
+ let n = (((n1 - 0xD800) as u32) << 10 | (n2 - 0xDC00) as u32) + 0x1_0000;
+
+ match char::from_u32(n) {
+ Some(c) => c,
+ None => {
+ return error(read, ErrorCode::InvalidUnicodeCodePoint);
+ }
+ }
+ }
+
+ n => match char::from_u32(n as u32) {
+ Some(c) => c,
+ None => {
+ return error(read, ErrorCode::InvalidUnicodeCodePoint);
+ }
+ },
+ };
+
+ scratch.extend_from_slice(c.encode_utf8(&mut [0_u8; 4]).as_bytes());
+ }
+ _ => {
+ return error(read, ErrorCode::InvalidEscape);
+ }
+ }
+
+ Ok(())
+}
+
+/// Parses a JSON escape sequence and discards the value. Assumes the previous
+/// byte read was a backslash.
+fn ignore_escape<'de, R: ?Sized + Read<'de>>(read: &mut R) -> Result<()> {
+ let ch = try!(next_or_eof(read));
+
+ match ch {
+ b'"' | b'\\' | b'/' | b'b' | b'f' | b'n' | b'r' | b't' => {}
+ b'u' => {
+ let n = match try!(decode_hex_escape(read)) {
+ 0xDC00...0xDFFF => {
+ return error(read, ErrorCode::LoneLeadingSurrogateInHexEscape);
+ }
+
+ // Non-BMP characters are encoded as a sequence of
+ // two hex escapes, representing UTF-16 surrogates.
+ n1 @ 0xD800...0xDBFF => {
+ if try!(next_or_eof(read)) != b'\\' {
+ return error(read, ErrorCode::UnexpectedEndOfHexEscape);
+ }
+ if try!(next_or_eof(read)) != b'u' {
+ return error(read, ErrorCode::UnexpectedEndOfHexEscape);
+ }
+
+ let n2 = try!(decode_hex_escape(read));
+
+ if n2 < 0xDC00 || n2 > 0xDFFF {
+ return error(read, ErrorCode::LoneLeadingSurrogateInHexEscape);
+ }
+
+ (((n1 - 0xD800) as u32) << 10 | (n2 - 0xDC00) as u32) + 0x1_0000
+ }
+
+ n => n as u32,
+ };
+
+ if char::from_u32(n).is_none() {
+ return error(read, ErrorCode::InvalidUnicodeCodePoint);
+ }
+ }
+ _ => {
+ return error(read, ErrorCode::InvalidEscape);
+ }
+ }
+
+ Ok(())
+}
+
+fn decode_hex_escape<'de, R: ?Sized + Read<'de>>(read: &mut R) -> Result<u16> {
+ let mut n = 0;
+ for _ in 0..4 {
+ n = match try!(next_or_eof(read)) {
+ c @ b'0'...b'9' => n * 16_u16 + ((c as u16) - (b'0' as u16)),
+ b'a' | b'A' => n * 16_u16 + 10_u16,
+ b'b' | b'B' => n * 16_u16 + 11_u16,
+ b'c' | b'C' => n * 16_u16 + 12_u16,
+ b'd' | b'D' => n * 16_u16 + 13_u16,
+ b'e' | b'E' => n * 16_u16 + 14_u16,
+ b'f' | b'F' => n * 16_u16 + 15_u16,
+ _ => {
+ return error(read, ErrorCode::InvalidEscape);
+ }
+ };
+ }
+ Ok(n)
+}
new file mode 100644
--- /dev/null
+++ b/third_party/rust/serde_json/src/ser.rs
@@ -0,0 +1,2092 @@
+// Copyright 2017 Serde Developers
+//
+// Licensed under the Apache License, Version 2.0 <LICENSE-APACHE or
+// http://www.apache.org/licenses/LICENSE-2.0> or the MIT license
+// <LICENSE-MIT or http://opensource.org/licenses/MIT>, at your
+// option. This file may not be copied, modified, or distributed
+// except according to those terms.
+
+//! Serialize a Rust data structure into JSON data.
+
+use std::fmt;
+use std::io;
+use std::num::FpCategory;
+use std::str;
+
+use super::error::{Error, ErrorCode, Result};
+use serde::ser::{self, Impossible};
+
+use dtoa;
+use itoa;
+
+#[cfg(feature = "arbitrary_precision")]
+use serde::Serialize;
+
+#[cfg(feature = "arbitrary_precision")]
+use number::{SERDE_STRUCT_FIELD_NAME, SERDE_STRUCT_NAME};
+
+/// A structure for serializing Rust values into JSON.
+pub struct Serializer<W, F = CompactFormatter> {
+ writer: W,
+ formatter: F,
+}
+
+impl<W> Serializer<W>
+where
+ W: io::Write,
+{
+ /// Creates a new JSON serializer.
+ #[inline]
+ pub fn new(writer: W) -> Self {
+ Serializer::with_formatter(writer, CompactFormatter)
+ }
+}
+
+impl<'a, W> Serializer<W, PrettyFormatter<'a>>
+where
+ W: io::Write,
+{
+ /// Creates a new JSON pretty print serializer.
+ #[inline]
+ pub fn pretty(writer: W) -> Self {
+ Serializer::with_formatter(writer, PrettyFormatter::new())
+ }
+}
+
+impl<W, F> Serializer<W, F>
+where
+ W: io::Write,
+ F: Formatter,
+{
+ /// Creates a new JSON visitor whose output will be written to the writer
+ /// specified.
+ #[inline]
+ pub fn with_formatter(writer: W, formatter: F) -> Self {
+ Serializer {
+ writer: writer,
+ formatter: formatter,
+ }
+ }
+
+ /// Unwrap the `Writer` from the `Serializer`.
+ #[inline]
+ pub fn into_inner(self) -> W {
+ self.writer
+ }
+}
+
+impl<'a, W, F> ser::Serializer for &'a mut Serializer<W, F>
+where
+ W: io::Write,
+ F: Formatter,
+{
+ type Ok = ();
+ type Error = Error;
+
+ type SerializeSeq = Compound<'a, W, F>;
+ type SerializeTuple = Compound<'a, W, F>;
+ type SerializeTupleStruct = Compound<'a, W, F>;
+ type SerializeTupleVariant = Compound<'a, W, F>;
+ type SerializeMap = Compound<'a, W, F>;
+ type SerializeStruct = Compound<'a, W, F>;
+ type SerializeStructVariant = Compound<'a, W, F>;
+
+ #[inline]
+ fn serialize_bool(self, value: bool) -> Result<()> {
+ try!(
+ self.formatter
+ .write_bool(&mut self.writer, value)
+ .map_err(Error::io)
+ );
+ Ok(())
+ }
+
+ #[inline]
+ fn serialize_i8(self, value: i8) -> Result<()> {
+ try!(
+ self.formatter
+ .write_i8(&mut self.writer, value)
+ .map_err(Error::io)
+ );
+ Ok(())
+ }
+
+ #[inline]
+ fn serialize_i16(self, value: i16) -> Result<()> {
+ try!(
+ self.formatter
+ .write_i16(&mut self.writer, value)
+ .map_err(Error::io)
+ );
+ Ok(())
+ }
+
+ #[inline]
+ fn serialize_i32(self, value: i32) -> Result<()> {
+ try!(
+ self.formatter
+ .write_i32(&mut self.writer, value)
+ .map_err(Error::io)
+ );
+ Ok(())
+ }
+
+ #[inline]
+ fn serialize_i64(self, value: i64) -> Result<()> {
+ try!(
+ self.formatter
+ .write_i64(&mut self.writer, value)
+ .map_err(Error::io)
+ );
+ Ok(())
+ }
+
+ serde_if_integer128! {
+ fn serialize_i128(self, value: i128) -> Result<()> {
+ self.formatter
+ .write_number_str(&mut self.writer, &value.to_string())
+ .map_err(Error::io)
+ }
+ }
+
+ #[inline]
+ fn serialize_u8(self, value: u8) -> Result<()> {
+ try!(
+ self.formatter
+ .write_u8(&mut self.writer, value)
+ .map_err(Error::io)
+ );
+ Ok(())
+ }
+
+ #[inline]
+ fn serialize_u16(self, value: u16) -> Result<()> {
+ try!(
+ self.formatter
+ .write_u16(&mut self.writer, value)
+ .map_err(Error::io)
+ );
+ Ok(())
+ }
+
+ #[inline]
+ fn serialize_u32(self, value: u32) -> Result<()> {
+ try!(
+ self.formatter
+ .write_u32(&mut self.writer, value)
+ .map_err(Error::io)
+ );
+ Ok(())
+ }
+
+ #[inline]
+ fn serialize_u64(self, value: u64) -> Result<()> {
+ try!(
+ self.formatter
+ .write_u64(&mut self.writer, value)
+ .map_err(Error::io)
+ );
+ Ok(())
+ }
+
+ serde_if_integer128! {
+ fn serialize_u128(self, value: u128) -> Result<()> {
+ self.formatter
+ .write_number_str(&mut self.writer, &value.to_string())
+ .map_err(Error::io)
+ }
+ }
+
+ #[inline]
+ fn serialize_f32(self, value: f32) -> Result<()> {
+ match value.classify() {
+ FpCategory::Nan | FpCategory::Infinite => {
+ try!(
+ self.formatter
+ .write_null(&mut self.writer)
+ .map_err(Error::io)
+ );
+ }
+ _ => {
+ try!(
+ self.formatter
+ .write_f32(&mut self.writer, value)
+ .map_err(Error::io)
+ );
+ }
+ }
+ Ok(())
+ }
+
+ #[inline]
+ fn serialize_f64(self, value: f64) -> Result<()> {
+ match value.classify() {
+ FpCategory::Nan | FpCategory::Infinite => {
+ try!(
+ self.formatter
+ .write_null(&mut self.writer)
+ .map_err(Error::io)
+ );
+ }
+ _ => {
+ try!(
+ self.formatter
+ .write_f64(&mut self.writer, value)
+ .map_err(Error::io)
+ );
+ }
+ }
+ Ok(())
+ }
+
+ #[inline]
+ fn serialize_char(self, value: char) -> Result<()> {
+ // A char encoded as UTF-8 takes 4 bytes at most.
+ let mut buf = [0; 4];
+ self.serialize_str(value.encode_utf8(&mut buf))
+ }
+
+ #[inline]
+ fn serialize_str(self, value: &str) -> Result<()> {
+ try!(format_escaped_str(&mut self.writer, &mut self.formatter, value).map_err(Error::io));
+ Ok(())
+ }
+
+ #[inline]
+ fn serialize_bytes(self, value: &[u8]) -> Result<()> {
+ use serde::ser::SerializeSeq;
+ let mut seq = try!(self.serialize_seq(Some(value.len())));
+ for byte in value {
+ try!(seq.serialize_element(byte));
+ }
+ seq.end()
+ }
+
+ #[inline]
+ fn serialize_unit(self) -> Result<()> {
+ try!(
+ self.formatter
+ .write_null(&mut self.writer)
+ .map_err(Error::io)
+ );
+ Ok(())
+ }
+
+ #[inline]
+ fn serialize_unit_struct(self, _name: &'static str) -> Result<()> {
+ self.serialize_unit()
+ }
+
+ #[inline]
+ fn serialize_unit_variant(
+ self,
+ _name: &'static str,
+ _variant_index: u32,
+ variant: &'static str,
+ ) -> Result<()> {
+ self.serialize_str(variant)
+ }
+
+ /// Serialize newtypes without an object wrapper.
+ #[inline]
+ fn serialize_newtype_struct<T: ?Sized>(self, _name: &'static str, value: &T) -> Result<()>
+ where
+ T: ser::Serialize,
+ {
+ value.serialize(self)
+ }
+
+ #[inline]
+ fn serialize_newtype_variant<T: ?Sized>(
+ self,
+ _name: &'static str,
+ _variant_index: u32,
+ variant: &'static str,
+ value: &T,
+ ) -> Result<()>
+ where
+ T: ser::Serialize,
+ {
+ try!(
+ self.formatter
+ .begin_object(&mut self.writer)
+ .map_err(Error::io)
+ );
+ try!(
+ self.formatter
+ .begin_object_key(&mut self.writer, true)
+ .map_err(Error::io)
+ );
+ try!(self.serialize_str(variant));
+ try!(
+ self.formatter
+ .end_object_key(&mut self.writer)
+ .map_err(Error::io)
+ );
+ try!(
+ self.formatter
+ .begin_object_value(&mut self.writer)
+ .map_err(Error::io)
+ );
+ try!(value.serialize(&mut *self));
+ try!(
+ self.formatter
+ .end_object_value(&mut self.writer)
+ .map_err(Error::io)
+ );
+ try!(
+ self.formatter
+ .end_object(&mut self.writer)
+ .map_err(Error::io)
+ );
+ Ok(())
+ }
+
+ #[inline]
+ fn serialize_none(self) -> Result<()> {
+ self.serialize_unit()
+ }
+
+ #[inline]
+ fn serialize_some<T: ?Sized>(self, value: &T) -> Result<()>
+ where
+ T: ser::Serialize,
+ {
+ value.serialize(self)
+ }
+
+ #[inline]
+ fn serialize_seq(self, len: Option<usize>) -> Result<Self::SerializeSeq> {
+ if len == Some(0) {
+ try!(
+ self.formatter
+ .begin_array(&mut self.writer)
+ .map_err(Error::io)
+ );
+ try!(
+ self.formatter
+ .end_array(&mut self.writer)
+ .map_err(Error::io)
+ );
+ Ok(Compound::Map {
+ ser: self,
+ state: State::Empty,
+ })
+ } else {
+ try!(
+ self.formatter
+ .begin_array(&mut self.writer)
+ .map_err(Error::io)
+ );
+ Ok(Compound::Map {
+ ser: self,
+ state: State::First,
+ })
+ }
+ }
+
+ #[inline]
+ fn serialize_tuple(self, len: usize) -> Result<Self::SerializeTuple> {
+ self.serialize_seq(Some(len))
+ }
+
+ #[inline]
+ fn serialize_tuple_struct(
+ self,
+ _name: &'static str,
+ len: usize,
+ ) -> Result<Self::SerializeTupleStruct> {
+ self.serialize_seq(Some(len))
+ }
+
+ #[inline]
+ fn serialize_tuple_variant(
+ self,
+ _name: &'static str,
+ _variant_index: u32,
+ variant: &'static str,
+ len: usize,
+ ) -> Result<Self::SerializeTupleVariant> {
+ try!(
+ self.formatter
+ .begin_object(&mut self.writer)
+ .map_err(Error::io)
+ );
+ try!(
+ self.formatter
+ .begin_object_key(&mut self.writer, true)
+ .map_err(Error::io)
+ );
+ try!(self.serialize_str(variant));
+ try!(
+ self.formatter
+ .end_object_key(&mut self.writer)
+ .map_err(Error::io)
+ );
+ try!(
+ self.formatter
+ .begin_object_value(&mut self.writer)
+ .map_err(Error::io)
+ );
+ self.serialize_seq(Some(len))
+ }
+
+ #[inline]
+ fn serialize_map(self, len: Option<usize>) -> Result<Self::SerializeMap> {
+ if len == Some(0) {
+ try!(
+ self.formatter
+ .begin_object(&mut self.writer)
+ .map_err(Error::io)
+ );
+ try!(
+ self.formatter
+ .end_object(&mut self.writer)
+ .map_err(Error::io)
+ );
+ Ok(Compound::Map {
+ ser: self,
+ state: State::Empty,
+ })
+ } else {
+ try!(
+ self.formatter
+ .begin_object(&mut self.writer)
+ .map_err(Error::io)
+ );
+ Ok(Compound::Map {
+ ser: self,
+ state: State::First,
+ })
+ }
+ }
+
+ #[cfg(not(feature = "arbitrary_precision"))]
+ #[inline]
+ fn serialize_struct(self, _name: &'static str, len: usize) -> Result<Self::SerializeStruct> {
+ self.serialize_map(Some(len))
+ }
+
+ #[cfg(feature = "arbitrary_precision")]
+ #[inline]
+ fn serialize_struct(self, name: &'static str, len: usize) -> Result<Self::SerializeStruct> {
+ if name == SERDE_STRUCT_NAME {
+ Ok(Compound::Number { ser: self })
+ } else {
+ self.serialize_map(Some(len))
+ }
+ }
+
+ #[inline]
+ fn serialize_struct_variant(
+ self,
+ _name: &'static str,
+ _variant_index: u32,
+ variant: &'static str,
+ len: usize,
+ ) -> Result<Self::SerializeStructVariant> {
+ try!(
+ self.formatter
+ .begin_object(&mut self.writer)
+ .map_err(Error::io)
+ );
+ try!(
+ self.formatter
+ .begin_object_key(&mut self.writer, true)
+ .map_err(Error::io)
+ );
+ try!(self.serialize_str(variant));
+ try!(
+ self.formatter
+ .end_object_key(&mut self.writer)
+ .map_err(Error::io)
+ );
+ try!(
+ self.formatter
+ .begin_object_value(&mut self.writer)
+ .map_err(Error::io)
+ );
+ self.serialize_map(Some(len))
+ }
+
+ fn collect_str<T: ?Sized>(self, value: &T) -> Result<Self::Ok>
+ where
+ T: fmt::Display,
+ {
+ use std::fmt::Write;
+
+ struct Adapter<'ser, W: 'ser, F: 'ser> {
+ writer: &'ser mut W,
+ formatter: &'ser mut F,
+ error: Option<io::Error>,
+ }
+
+ impl<'ser, W, F> Write for Adapter<'ser, W, F>
+ where
+ W: io::Write,
+ F: Formatter,
+ {
+ fn write_str(&mut self, s: &str) -> fmt::Result {
+ assert!(self.error.is_none());
+ match format_escaped_str_contents(self.writer, self.formatter, s) {
+ Ok(()) => Ok(()),
+ Err(err) => {
+ self.error = Some(err);
+ Err(fmt::Error)
+ }
+ }
+ }
+ }
+
+ try!(
+ self.formatter
+ .begin_string(&mut self.writer)
+ .map_err(Error::io)
+ );
+ {
+ let mut adapter = Adapter {
+ writer: &mut self.writer,
+ formatter: &mut self.formatter,
+ error: None,
+ };
+ match write!(adapter, "{}", value) {
+ Ok(()) => assert!(adapter.error.is_none()),
+ Err(fmt::Error) => {
+ return Err(Error::io(adapter.error.expect("there should be an error")));
+ }
+ }
+ }
+ try!(
+ self.formatter
+ .end_string(&mut self.writer)
+ .map_err(Error::io)
+ );
+ Ok(())
+ }
+}
+
+#[derive(Eq, PartialEq)]
+/// Not public API. Should be pub(crate).
+#[doc(hidden)]
+pub enum State {
+ Empty,
+ First,
+ Rest,
+}
+
+/// Not public API. Should be pub(crate).
+#[doc(hidden)]
+pub enum Compound<'a, W: 'a, F: 'a> {
+ Map {
+ ser: &'a mut Serializer<W, F>,
+ state: State,
+ },
+ #[cfg(feature = "arbitrary_precision")]
+ Number { ser: &'a mut Serializer<W, F> },
+}
+
+impl<'a, W, F> ser::SerializeSeq for Compound<'a, W, F>
+where
+ W: io::Write,
+ F: Formatter,
+{
+ type Ok = ();
+ type Error = Error;
+
+ #[inline]
+ fn serialize_element<T: ?Sized>(&mut self, value: &T) -> Result<()>
+ where
+ T: ser::Serialize,
+ {
+ match *self {
+ Compound::Map {
+ ref mut ser,
+ ref mut state,
+ } => {
+ try!(
+ ser.formatter
+ .begin_array_value(&mut ser.writer, *state == State::First)
+ .map_err(Error::io)
+ );
+ *state = State::Rest;
+ try!(value.serialize(&mut **ser));
+ try!(
+ ser.formatter
+ .end_array_value(&mut ser.writer)
+ .map_err(Error::io)
+ );
+ Ok(())
+ }
+ #[cfg(feature = "arbitrary_precision")]
+ Compound::Number { .. } => unreachable!(),
+ }
+ }
+
+ #[inline]
+ fn end(self) -> Result<()> {
+ match self {
+ Compound::Map { ser, state } => {
+ match state {
+ State::Empty => {}
+ _ => try!(ser.formatter.end_array(&mut ser.writer).map_err(Error::io)),
+ }
+ Ok(())
+ }
+ #[cfg(feature = "arbitrary_precision")]
+ Compound::Number { .. } => unreachable!(),
+ }
+ }
+}
+
+impl<'a, W, F> ser::SerializeTuple for Compound<'a, W, F>
+where
+ W: io::Write,
+ F: Formatter,
+{
+ type Ok = ();
+ type Error = Error;
+
+ #[inline]
+ fn serialize_element<T: ?Sized>(&mut self, value: &T) -> Result<()>
+ where
+ T: ser::Serialize,
+ {
+ ser::SerializeSeq::serialize_element(self, value)
+ }
+
+ #[inline]
+ fn end(self) -> Result<()> {
+ ser::SerializeSeq::end(self)
+ }
+}
+
+impl<'a, W, F> ser::SerializeTupleStruct for Compound<'a, W, F>
+where
+ W: io::Write,
+ F: Formatter,
+{
+ type Ok = ();
+ type Error = Error;
+
+ #[inline]
+ fn serialize_field<T: ?Sized>(&mut self, value: &T) -> Result<()>
+ where
+ T: ser::Serialize,
+ {
+ ser::SerializeSeq::serialize_element(self, value)
+ }
+
+ #[inline]
+ fn end(self) -> Result<()> {
+ ser::SerializeSeq::end(self)
+ }
+}
+
+impl<'a, W, F> ser::SerializeTupleVariant for Compound<'a, W, F>
+where
+ W: io::Write,
+ F: Formatter,
+{
+ type Ok = ();
+ type Error = Error;
+
+ #[inline]
+ fn serialize_field<T: ?Sized>(&mut self, value: &T) -> Result<()>
+ where
+ T: ser::Serialize,
+ {
+ ser::SerializeSeq::serialize_element(self, value)
+ }
+
+ #[inline]
+ fn end(self) -> Result<()> {
+ match self {
+ Compound::Map { ser, state } => {
+ match state {
+ State::Empty => {}
+ _ => try!(ser.formatter.end_array(&mut ser.writer).map_err(Error::io)),
+ }
+ try!(
+ ser.formatter
+ .end_object_value(&mut ser.writer)
+ .map_err(Error::io)
+ );
+ try!(ser.formatter.end_object(&mut ser.writer).map_err(Error::io));
+ Ok(())
+ }
+ #[cfg(feature = "arbitrary_precision")]
+ Compound::Number { .. } => unreachable!(),
+ }
+ }
+}
+
+impl<'a, W, F> ser::SerializeMap for Compound<'a, W, F>
+where
+ W: io::Write,
+ F: Formatter,
+{
+ type Ok = ();
+ type Error = Error;
+
+ #[inline]
+ fn serialize_key<T: ?Sized>(&mut self, key: &T) -> Result<()>
+ where
+ T: ser::Serialize,
+ {
+ match *self {
+ Compound::Map {
+ ref mut ser,
+ ref mut state,
+ } => {
+ try!(
+ ser.formatter
+ .begin_object_key(&mut ser.writer, *state == State::First)
+ .map_err(Error::io)
+ );
+ *state = State::Rest;
+
+ try!(key.serialize(MapKeySerializer { ser: *ser }));
+
+ try!(
+ ser.formatter
+ .end_object_key(&mut ser.writer)
+ .map_err(Error::io)
+ );
+ Ok(())
+ }
+ #[cfg(feature = "arbitrary_precision")]
+ Compound::Number { .. } => unreachable!(),
+ }
+ }
+
+ #[inline]
+ fn serialize_value<T: ?Sized>(&mut self, value: &T) -> Result<()>
+ where
+ T: ser::Serialize,
+ {
+ match *self {
+ Compound::Map { ref mut ser, .. } => {
+ try!(
+ ser.formatter
+ .begin_object_value(&mut ser.writer)
+ .map_err(Error::io)
+ );
+ try!(value.serialize(&mut **ser));
+ try!(
+ ser.formatter
+ .end_object_value(&mut ser.writer)
+ .map_err(Error::io)
+ );
+ Ok(())
+ }
+ #[cfg(feature = "arbitrary_precision")]
+ Compound::Number { .. } => unreachable!(),
+ }
+ }
+
+ #[inline]
+ fn end(self) -> Result<()> {
+ match self {
+ Compound::Map { ser, state } => {
+ match state {
+ State::Empty => {}
+ _ => try!(ser.formatter.end_object(&mut ser.writer).map_err(Error::io)),
+ }
+ Ok(())
+ }
+ #[cfg(feature = "arbitrary_precision")]
+ Compound::Number { .. } => unreachable!(),
+ }
+ }
+}
+
+impl<'a, W, F> ser::SerializeStruct for Compound<'a, W, F>
+where
+ W: io::Write,
+ F: Formatter,
+{
+ type Ok = ();
+ type Error = Error;
+
+ #[inline]
+ fn serialize_field<T: ?Sized>(&mut self, key: &'static str, value: &T) -> Result<()>
+ where
+ T: ser::Serialize,
+ {
+ match *self {
+ Compound::Map { .. } => {
+ try!(ser::SerializeMap::serialize_key(self, key));
+ ser::SerializeMap::serialize_value(self, value)
+ }
+ #[cfg(feature = "arbitrary_precision")]
+ Compound::Number { ref mut ser, .. } => {
+ if key == SERDE_STRUCT_FIELD_NAME {
+ try!(value.serialize(NumberStrEmitter(&mut *ser)));
+ Ok(())
+ } else {
+ Err(invalid_number())
+ }
+ }
+ }
+ }
+
+ #[inline]
+ fn end(self) -> Result<()> {
+ match self {
+ Compound::Map { .. } => ser::SerializeMap::end(self),
+ #[cfg(feature = "arbitrary_precision")]
+ Compound::Number { .. } => Ok(()),
+ }
+ }
+}
+
+impl<'a, W, F> ser::SerializeStructVariant for Compound<'a, W, F>
+where
+ W: io::Write,
+ F: Formatter,
+{
+ type Ok = ();
+ type Error = Error;
+
+ #[inline]
+ fn serialize_field<T: ?Sized>(&mut self, key: &'static str, value: &T) -> Result<()>
+ where
+ T: ser::Serialize,
+ {
+ match *self {
+ Compound::Map { .. } => ser::SerializeStruct::serialize_field(self, key, value),
+ #[cfg(feature = "arbitrary_precision")]
+ Compound::Number { .. } => unreachable!(),
+ }
+ }
+
+ #[inline]
+ fn end(self) -> Result<()> {
+ match self {
+ Compound::Map { ser, state } => {
+ match state {
+ State::Empty => {}
+ _ => try!(ser.formatter.end_object(&mut ser.writer).map_err(Error::io)),
+ }
+ try!(
+ ser.formatter
+ .end_object_value(&mut ser.writer)
+ .map_err(Error::io)
+ );
+ try!(ser.formatter.end_object(&mut ser.writer).map_err(Error::io));
+ Ok(())
+ }
+ #[cfg(feature = "arbitrary_precision")]
+ Compound::Number { .. } => unreachable!(),
+ }
+ }
+}
+
+struct MapKeySerializer<'a, W: 'a, F: 'a> {
+ ser: &'a mut Serializer<W, F>,
+}
+
+#[cfg(feature = "arbitrary_precision")]
+fn invalid_number() -> Error {
+ Error::syntax(ErrorCode::InvalidNumber, 0, 0)
+}
+
+fn key_must_be_a_string() -> Error {
+ Error::syntax(ErrorCode::KeyMustBeAString, 0, 0)
+}
+
+impl<'a, W, F> ser::Serializer for MapKeySerializer<'a, W, F>
+where
+ W: io::Write,
+ F: Formatter,
+{
+ type Ok = ();
+ type Error = Error;
+
+ #[inline]
+ fn serialize_str(self, value: &str) -> Result<()> {
+ self.ser.serialize_str(value)
+ }
+
+ #[inline]
+ fn serialize_unit_variant(
+ self,
+ _name: &'static str,
+ _variant_index: u32,
+ variant: &'static str,
+ ) -> Result<()> {
+ self.ser.serialize_str(variant)
+ }
+
+ #[inline]
+ fn serialize_newtype_struct<T: ?Sized>(self, _name: &'static str, value: &T) -> Result<()>
+ where
+ T: ser::Serialize,
+ {
+ value.serialize(self)
+ }
+
+ type SerializeSeq = Impossible<(), Error>;
+ type SerializeTuple = Impossible<(), Error>;
+ type SerializeTupleStruct = Impossible<(), Error>;
+ type SerializeTupleVariant = Impossible<(), Error>;
+ type SerializeMap = Impossible<(), Error>;
+ type SerializeStruct = Impossible<(), Error>;
+ type SerializeStructVariant = Impossible<(), Error>;
+
+ fn serialize_bool(self, _value: bool) -> Result<()> {
+ Err(key_must_be_a_string())
+ }
+
+ fn serialize_i8(self, value: i8) -> Result<()> {
+ try!(
+ self.ser
+ .formatter
+ .begin_string(&mut self.ser.writer)
+ .map_err(Error::io)
+ );
+ try!(
+ self.ser
+ .formatter
+ .write_i8(&mut self.ser.writer, value)
+ .map_err(Error::io)
+ );
+ try!(
+ self.ser
+ .formatter
+ .end_string(&mut self.ser.writer)
+ .map_err(Error::io)
+ );
+ Ok(())
+ }
+
+ fn serialize_i16(self, value: i16) -> Result<()> {
+ try!(
+ self.ser
+ .formatter
+ .begin_string(&mut self.ser.writer)
+ .map_err(Error::io)
+ );
+ try!(
+ self.ser
+ .formatter
+ .write_i16(&mut self.ser.writer, value)
+ .map_err(Error::io)
+ );
+ try!(
+ self.ser
+ .formatter
+ .end_string(&mut self.ser.writer)
+ .map_err(Error::io)
+ );
+ Ok(())
+ }
+
+ fn serialize_i32(self, value: i32) -> Result<()> {
+ try!(
+ self.ser
+ .formatter
+ .begin_string(&mut self.ser.writer)
+ .map_err(Error::io)
+ );
+ try!(
+ self.ser
+ .formatter
+ .write_i32(&mut self.ser.writer, value)
+ .map_err(Error::io)
+ );
+ try!(
+ self.ser
+ .formatter
+ .end_string(&mut self.ser.writer)
+ .map_err(Error::io)
+ );
+ Ok(())
+ }
+
+ fn serialize_i64(self, value: i64) -> Result<()> {
+ try!(
+ self.ser
+ .formatter
+ .begin_string(&mut self.ser.writer)
+ .map_err(Error::io)
+ );
+ try!(
+ self.ser
+ .formatter
+ .write_i64(&mut self.ser.writer, value)
+ .map_err(Error::io)
+ );
+ try!(
+ self.ser
+ .formatter
+ .end_string(&mut self.ser.writer)
+ .map_err(Error::io)
+ );
+ Ok(())
+ }
+
+ serde_if_integer128! {
+ fn serialize_i128(self, value: i128) -> Result<()> {
+ self.ser
+ .formatter
+ .write_number_str(&mut self.ser.writer, &value.to_string())
+ .map_err(Error::io)
+ }
+ }
+
+ fn serialize_u8(self, value: u8) -> Result<()> {
+ try!(
+ self.ser
+ .formatter
+ .begin_string(&mut self.ser.writer)
+ .map_err(Error::io)
+ );
+ try!(
+ self.ser
+ .formatter
+ .write_u8(&mut self.ser.writer, value)
+ .map_err(Error::io)
+ );
+ try!(
+ self.ser
+ .formatter
+ .end_string(&mut self.ser.writer)
+ .map_err(Error::io)
+ );
+ Ok(())
+ }
+
+ fn serialize_u16(self, value: u16) -> Result<()> {
+ try!(
+ self.ser
+ .formatter
+ .begin_string(&mut self.ser.writer)
+ .map_err(Error::io)
+ );
+ try!(
+ self.ser
+ .formatter
+ .write_u16(&mut self.ser.writer, value)
+ .map_err(Error::io)
+ );
+ try!(
+ self.ser
+ .formatter
+ .end_string(&mut self.ser.writer)
+ .map_err(Error::io)
+ );
+ Ok(())
+ }
+
+ fn serialize_u32(self, value: u32) -> Result<()> {
+ try!(
+ self.ser
+ .formatter
+ .begin_string(&mut self.ser.writer)
+ .map_err(Error::io)
+ );
+ try!(
+ self.ser
+ .formatter
+ .write_u32(&mut self.ser.writer, value)
+ .map_err(Error::io)
+ );
+ try!(
+ self.ser
+ .formatter
+ .end_string(&mut self.ser.writer)
+ .map_err(Error::io)
+ );
+ Ok(())
+ }
+
+ fn serialize_u64(self, value: u64) -> Result<()> {
+ try!(
+ self.ser
+ .formatter
+ .begin_string(&mut self.ser.writer)
+ .map_err(Error::io)
+ );
+ try!(
+ self.ser
+ .formatter
+ .write_u64(&mut self.ser.writer, value)
+ .map_err(Error::io)
+ );
+ try!(
+ self.ser
+ .formatter
+ .end_string(&mut self.ser.writer)
+ .map_err(Error::io)
+ );
+ Ok(())
+ }
+
+ serde_if_integer128! {
+ fn serialize_u128(self, value: u128) -> Result<()> {
+ self.ser
+ .formatter
+ .write_number_str(&mut self.ser.writer, &value.to_string())
+ .map_err(Error::io)
+ }
+ }
+
+ fn serialize_f32(self, _value: f32) -> Result<()> {
+ Err(key_must_be_a_string())
+ }
+
+ fn serialize_f64(self, _value: f64) -> Result<()> {
+ Err(key_must_be_a_string())
+ }
+
+ fn serialize_char(self, value: char) -> Result<()> {
+ self.ser.serialize_str(&value.to_string())
+ }
+
+ fn serialize_bytes(self, _value: &[u8]) -> Result<()> {
+ Err(key_must_be_a_string())
+ }
+
+ fn serialize_unit(self) -> Result<()> {
+ Err(key_must_be_a_string())
+ }
+
+ fn serialize_unit_struct(self, _name: &'static str) -> Result<()> {
+ Err(key_must_be_a_string())
+ }
+
+ fn serialize_newtype_variant<T: ?Sized>(
+ self,
+ _name: &'static str,
+ _variant_index: u32,
+ _variant: &'static str,
+ _value: &T,
+ ) -> Result<()>
+ where
+ T: ser::Serialize,
+ {
+ Err(key_must_be_a_string())
+ }
+
+ fn serialize_none(self) -> Result<()> {
+ Err(key_must_be_a_string())
+ }
+
+ fn serialize_some<T: ?Sized>(self, _value: &T) -> Result<()>
+ where
+ T: ser::Serialize,
+ {
+ Err(key_must_be_a_string())
+ }
+
+ fn serialize_seq(self, _len: Option<usize>) -> Result<Self::SerializeSeq> {
+ Err(key_must_be_a_string())
+ }
+
+ fn serialize_tuple(self, _len: usize) -> Result<Self::SerializeTuple> {
+ Err(key_must_be_a_string())
+ }
+
+ fn serialize_tuple_struct(
+ self,
+ _name: &'static str,
+ _len: usize,
+ ) -> Result<Self::SerializeTupleStruct> {
+ Err(key_must_be_a_string())
+ }
+
+ fn serialize_tuple_variant(
+ self,
+ _name: &'static str,
+ _variant_index: u32,
+ _variant: &'static str,
+ _len: usize,
+ ) -> Result<Self::SerializeTupleVariant> {
+ Err(key_must_be_a_string())
+ }
+
+ fn serialize_map(self, _len: Option<usize>) -> Result<Self::SerializeMap> {
+ Err(key_must_be_a_string())
+ }
+
+ fn serialize_struct(self, _name: &'static str, _len: usize) -> Result<Self::SerializeStruct> {
+ Err(key_must_be_a_string())
+ }
+
+ fn serialize_struct_variant(
+ self,
+ _name: &'static str,
+ _variant_index: u32,
+ _variant: &'static str,
+ _len: usize,
+ ) -> Result<Self::SerializeStructVariant> {
+ Err(key_must_be_a_string())
+ }
+}
+
+#[cfg(feature = "arbitrary_precision")]
+struct NumberStrEmitter<'a, W: 'a + io::Write, F: 'a + Formatter>(&'a mut Serializer<W, F>);
+
+#[cfg(feature = "arbitrary_precision")]
+impl<'a, W: io::Write, F: Formatter> ser::Serializer for NumberStrEmitter<'a, W, F> {
+ type Ok = ();
+ type Error = Error;
+
+ type SerializeSeq = Impossible<(), Error>;
+ type SerializeTuple = Impossible<(), Error>;
+ type SerializeTupleStruct = Impossible<(), Error>;
+ type SerializeTupleVariant = Impossible<(), Error>;
+ type SerializeMap = Impossible<(), Error>;
+ type SerializeStruct = Impossible<(), Error>;
+ type SerializeStructVariant = Impossible<(), Error>;
+
+ fn serialize_bool(self, _v: bool) -> Result<Self::Ok> {
+ Err(invalid_number())
+ }
+
+ fn serialize_i8(self, _v: i8) -> Result<Self::Ok> {
+ Err(invalid_number())
+ }
+
+ fn serialize_i16(self, _v: i16) -> Result<Self::Ok> {
+ Err(invalid_number())
+ }
+
+ fn serialize_i32(self, _v: i32) -> Result<Self::Ok> {
+ Err(invalid_number())
+ }
+
+ fn serialize_i64(self, _v: i64) -> Result<Self::Ok> {
+ Err(invalid_number())
+ }
+
+ serde_if_integer128! {
+ fn serialize_i128(self, _v: i128) -> Result<Self::Ok> {
+ Err(invalid_number())
+ }
+ }
+
+ fn serialize_u8(self, _v: u8) -> Result<Self::Ok> {
+ Err(invalid_number())
+ }
+
+ fn serialize_u16(self, _v: u16) -> Result<Self::Ok> {
+ Err(invalid_number())
+ }
+
+ fn serialize_u32(self, _v: u32) -> Result<Self::Ok> {
+ Err(invalid_number())
+ }
+
+ fn serialize_u64(self, _v: u64) -> Result<Self::Ok> {
+ Err(invalid_number())
+ }
+
+ serde_if_integer128! {
+ fn serialize_u128(self, _v: u128) -> Result<Self::Ok> {
+ Err(invalid_number())
+ }
+ }
+
+ fn serialize_f32(self, _v: f32) -> Result<Self::Ok> {
+ Err(invalid_number())
+ }
+
+ fn serialize_f64(self, _v: f64) -> Result<Self::Ok> {
+ Err(invalid_number())
+ }
+
+ fn serialize_char(self, _v: char) -> Result<Self::Ok> {
+ Err(invalid_number())
+ }
+
+ fn serialize_str(self, value: &str) -> Result<Self::Ok> {
+ let NumberStrEmitter(serializer) = self;
+ serializer
+ .formatter
+ .write_number_str(&mut serializer.writer, value)
+ .map_err(Error::io)
+ }
+
+ fn serialize_bytes(self, _value: &[u8]) -> Result<Self::Ok> {
+ Err(invalid_number())
+ }
+
+ fn serialize_none(self) -> Result<Self::Ok> {
+ Err(invalid_number())
+ }
+
+ fn serialize_some<T: ?Sized>(self, _value: &T) -> Result<Self::Ok>
+ where
+ T: Serialize,
+ {
+ Err(invalid_number())
+ }
+
+ fn serialize_unit(self) -> Result<Self::Ok> {
+ Err(invalid_number())
+ }
+
+ fn serialize_unit_struct(self, _name: &'static str) -> Result<Self::Ok> {
+ Err(invalid_number())
+ }
+
+ fn serialize_unit_variant(
+ self,
+ _name: &'static str,
+ _variant_index: u32,
+ _variant: &'static str,
+ ) -> Result<Self::Ok> {
+ Err(invalid_number())
+ }
+
+ fn serialize_newtype_struct<T: ?Sized>(
+ self,
+ _name: &'static str,
+ _value: &T,
+ ) -> Result<Self::Ok>
+ where
+ T: Serialize,
+ {
+ Err(invalid_number())
+ }
+
+ fn serialize_newtype_variant<T: ?Sized>(
+ self,
+ _name: &'static str,
+ _variant_index: u32,
+ _variant: &'static str,
+ _value: &T,
+ ) -> Result<Self::Ok>
+ where
+ T: Serialize,
+ {
+ Err(invalid_number())
+ }
+
+ fn serialize_seq(self, _len: Option<usize>) -> Result<Self::SerializeSeq> {
+ Err(invalid_number())
+ }
+
+ fn serialize_tuple(self, _len: usize) -> Result<Self::SerializeTuple> {
+ Err(invalid_number())
+ }
+
+ fn serialize_tuple_struct(
+ self,
+ _name: &'static str,
+ _len: usize,
+ ) -> Result<Self::SerializeTupleStruct> {
+ Err(invalid_number())
+ }
+
+ fn serialize_tuple_variant(
+ self,
+ _name: &'static str,
+ _variant_index: u32,
+ _variant: &'static str,
+ _len: usize,
+ ) -> Result<Self::SerializeTupleVariant> {
+ Err(invalid_number())
+ }
+
+ fn serialize_map(self, _len: Option<usize>) -> Result<Self::SerializeMap> {
+ Err(invalid_number())
+ }
+
+ fn serialize_struct(self, _name: &'static str, _len: usize) -> Result<Self::SerializeStruct> {
+ Err(invalid_number())
+ }
+
+ fn serialize_struct_variant(
+ self,
+ _name: &'static str,
+ _variant_index: u32,
+ _variant: &'static str,
+ _len: usize,
+ ) -> Result<Self::SerializeStructVariant> {
+ Err(invalid_number())
+ }
+}
+
+/// Represents a character escape code in a type-safe manner.
+pub enum CharEscape {
+ /// An escaped quote `"`
+ Quote,
+ /// An escaped reverse solidus `\`
+ ReverseSolidus,
+ /// An escaped solidus `/`
+ Solidus,
+ /// An escaped backspace character (usually escaped as `\b`)
+ Backspace,
+ /// An escaped form feed character (usually escaped as `\f`)
+ FormFeed,
+ /// An escaped line feed character (usually escaped as `\n`)
+ LineFeed,
+ /// An escaped carriage return character (usually escaped as `\r`)
+ CarriageReturn,
+ /// An escaped tab character (usually escaped as `\t`)
+ Tab,
+ /// An escaped ASCII plane control character (usually escaped as
+ /// `\u00XX` where `XX` are two hex characters)
+ AsciiControl(u8),
+}
+
+impl CharEscape {
+ #[inline]
+ fn from_escape_table(escape: u8, byte: u8) -> CharEscape {
+ match escape {
+ self::BB => CharEscape::Backspace,
+ self::TT => CharEscape::Tab,
+ self::NN => CharEscape::LineFeed,
+ self::FF => CharEscape::FormFeed,
+ self::RR => CharEscape::CarriageReturn,
+ self::QU => CharEscape::Quote,
+ self::BS => CharEscape::ReverseSolidus,
+ self::U => CharEscape::AsciiControl(byte),
+ _ => unreachable!(),
+ }
+ }
+}
+
+/// This trait abstracts away serializing the JSON control characters, which allows the user to
+/// optionally pretty print the JSON output.
+pub trait Formatter {
+ /// Writes a `null` value to the specified writer.
+ #[inline]
+ fn write_null<W: ?Sized>(&mut self, writer: &mut W) -> io::Result<()>
+ where
+ W: io::Write,
+ {
+ writer.write_all(b"null")
+ }
+
+ /// Writes a `true` or `false` value to the specified writer.
+ #[inline]
+ fn write_bool<W: ?Sized>(&mut self, writer: &mut W, value: bool) -> io::Result<()>
+ where
+ W: io::Write,
+ {
+ let s = if value {
+ b"true" as &[u8]
+ } else {
+ b"false" as &[u8]
+ };
+ writer.write_all(s)
+ }
+
+ /// Writes an integer value like `-123` to the specified writer.
+ #[inline]
+ fn write_i8<W: ?Sized>(&mut self, writer: &mut W, value: i8) -> io::Result<()>
+ where
+ W: io::Write,
+ {
+ itoa::write(writer, value).map(drop)
+ }
+
+ /// Writes an integer value like `-123` to the specified writer.
+ #[inline]
+ fn write_i16<W: ?Sized>(&mut self, writer: &mut W, value: i16) -> io::Result<()>
+ where
+ W: io::Write,
+ {
+ itoa::write(writer, value).map(drop)
+ }
+
+ /// Writes an integer value like `-123` to the specified writer.
+ #[inline]
+ fn write_i32<W: ?Sized>(&mut self, writer: &mut W, value: i32) -> io::Result<()>
+ where
+ W: io::Write,
+ {
+ itoa::write(writer, value).map(drop)
+ }
+
+ /// Writes an integer value like `-123` to the specified writer.
+ #[inline]
+ fn write_i64<W: ?Sized>(&mut self, writer: &mut W, value: i64) -> io::Result<()>
+ where
+ W: io::Write,
+ {
+ itoa::write(writer, value).map(drop)
+ }
+
+ /// Writes an integer value like `123` to the specified writer.
+ #[inline]
+ fn write_u8<W: ?Sized>(&mut self, writer: &mut W, value: u8) -> io::Result<()>
+ where
+ W: io::Write,
+ {
+ itoa::write(writer, value).map(drop)
+ }
+
+ /// Writes an integer value like `123` to the specified writer.
+ #[inline]
+ fn write_u16<W: ?Sized>(&mut self, writer: &mut W, value: u16) -> io::Result<()>
+ where
+ W: io::Write,
+ {
+ itoa::write(writer, value).map(drop)
+ }
+
+ /// Writes an integer value like `123` to the specified writer.
+ #[inline]
+ fn write_u32<W: ?Sized>(&mut self, writer: &mut W, value: u32) -> io::Result<()>
+ where
+ W: io::Write,
+ {
+ itoa::write(writer, value).map(drop)
+ }
+
+ /// Writes an integer value like `123` to the specified writer.
+ #[inline]
+ fn write_u64<W: ?Sized>(&mut self, writer: &mut W, value: u64) -> io::Result<()>
+ where
+ W: io::Write,
+ {
+ itoa::write(writer, value).map(drop)
+ }
+
+ /// Writes a floating point value like `-31.26e+12` to the specified writer.
+ #[inline]
+ fn write_f32<W: ?Sized>(&mut self, writer: &mut W, value: f32) -> io::Result<()>
+ where
+ W: io::Write,
+ {
+ dtoa::write(writer, value).map(drop)
+ }
+
+ /// Writes a floating point value like `-31.26e+12` to the specified writer.
+ #[inline]
+ fn write_f64<W: ?Sized>(&mut self, writer: &mut W, value: f64) -> io::Result<()>
+ where
+ W: io::Write,
+ {
+ dtoa::write(writer, value).map(drop)
+ }
+
+ /// Writes a number that has already been rendered to a string.
+ #[inline]
+ fn write_number_str<W: ?Sized>(&mut self, writer: &mut W, value: &str) -> io::Result<()>
+ where
+ W: io::Write,
+ {
+ writer.write_all(value.as_bytes())
+ }
+
+ /// Called before each series of `write_string_fragment` and
+ /// `write_char_escape`. Writes a `"` to the specified writer.
+ #[inline]
+ fn begin_string<W: ?Sized>(&mut self, writer: &mut W) -> io::Result<()>
+ where
+ W: io::Write,
+ {
+ writer.write_all(b"\"")
+ }
+
+ /// Called after each series of `write_string_fragment` and
+ /// `write_char_escape`. Writes a `"` to the specified writer.
+ #[inline]
+ fn end_string<W: ?Sized>(&mut self, writer: &mut W) -> io::Result<()>
+ where
+ W: io::Write,
+ {
+ writer.write_all(b"\"")
+ }
+
+ /// Writes a string fragment that doesn't need any escaping to the
+ /// specified writer.
+ #[inline]
+ fn write_string_fragment<W: ?Sized>(&mut self, writer: &mut W, fragment: &str) -> io::Result<()>
+ where
+ W: io::Write,
+ {
+ writer.write_all(fragment.as_bytes())
+ }
+
+ /// Writes a character escape code to the specified writer.
+ #[inline]
+ fn write_char_escape<W: ?Sized>(
+ &mut self,
+ writer: &mut W,
+ char_escape: CharEscape,
+ ) -> io::Result<()>
+ where
+ W: io::Write,
+ {
+ use self::CharEscape::*;
+
+ let s = match char_escape {
+ Quote => b"\\\"",
+ ReverseSolidus => b"\\\\",
+ Solidus => b"\\/",
+ Backspace => b"\\b",
+ FormFeed => b"\\f",
+ LineFeed => b"\\n",
+ CarriageReturn => b"\\r",
+ Tab => b"\\t",
+ AsciiControl(byte) => {
+ static HEX_DIGITS: [u8; 16] = *b"0123456789abcdef";
+ let bytes = &[
+ b'\\',
+ b'u',
+ b'0',
+ b'0',
+ HEX_DIGITS[(byte >> 4) as usize],
+ HEX_DIGITS[(byte & 0xF) as usize],
+ ];
+ return writer.write_all(bytes);
+ }
+ };
+
+ writer.write_all(s)
+ }
+
+ /// Called before every array. Writes a `[` to the specified
+ /// writer.
+ #[inline]
+ fn begin_array<W: ?Sized>(&mut self, writer: &mut W) -> io::Result<()>
+ where
+ W: io::Write,
+ {
+ writer.write_all(b"[")
+ }
+
+ /// Called after every array. Writes a `]` to the specified
+ /// writer.
+ #[inline]
+ fn end_array<W: ?Sized>(&mut self, writer: &mut W) -> io::Result<()>
+ where
+ W: io::Write,
+ {
+ writer.write_all(b"]")
+ }
+
+ /// Called before every array value. Writes a `,` if needed to
+ /// the specified writer.
+ #[inline]
+ fn begin_array_value<W: ?Sized>(&mut self, writer: &mut W, first: bool) -> io::Result<()>
+ where
+ W: io::Write,
+ {
+ if first {
+ Ok(())
+ } else {
+ writer.write_all(b",")
+ }
+ }
+
+ /// Called after every array value.
+ #[inline]
+ fn end_array_value<W: ?Sized>(&mut self, _writer: &mut W) -> io::Result<()>
+ where
+ W: io::Write,
+ {
+ Ok(())
+ }
+
+ /// Called before every object. Writes a `{` to the specified
+ /// writer.
+ #[inline]
+ fn begin_object<W: ?Sized>(&mut self, writer: &mut W) -> io::Result<()>
+ where
+ W: io::Write,
+ {
+ writer.write_all(b"{")
+ }
+
+ /// Called after every object. Writes a `}` to the specified
+ /// writer.
+ #[inline]
+ fn end_object<W: ?Sized>(&mut self, writer: &mut W) -> io::Result<()>
+ where
+ W: io::Write,
+ {
+ writer.write_all(b"}")
+ }
+
+ /// Called before every object key.
+ #[inline]
+ fn begin_object_key<W: ?Sized>(&mut self, writer: &mut W, first: bool) -> io::Result<()>
+ where
+ W: io::Write,
+ {
+ if first {
+ Ok(())
+ } else {
+ writer.write_all(b",")
+ }
+ }
+
+ /// Called after every object key. A `:` should be written to the
+ /// specified writer by either this method or
+ /// `begin_object_value`.
+ #[inline]
+ fn end_object_key<W: ?Sized>(&mut self, _writer: &mut W) -> io::Result<()>
+ where
+ W: io::Write,
+ {
+ Ok(())
+ }
+
+ /// Called before every object value. A `:` should be written to
+ /// the specified writer by either this method or
+ /// `end_object_key`.
+ #[inline]
+ fn begin_object_value<W: ?Sized>(&mut self, writer: &mut W) -> io::Result<()>
+ where
+ W: io::Write,
+ {
+ writer.write_all(b":")
+ }
+
+ /// Called after every object value.
+ #[inline]
+ fn end_object_value<W: ?Sized>(&mut self, _writer: &mut W) -> io::Result<()>
+ where
+ W: io::Write,
+ {
+ Ok(())
+ }
+}
+
+/// This structure compacts a JSON value with no extra whitespace.
+#[derive(Clone, Debug)]
+pub struct CompactFormatter;
+
+impl Formatter for CompactFormatter {}
+
+/// This structure pretty prints a JSON value to make it human readable.
+#[derive(Clone, Debug)]
+pub struct PrettyFormatter<'a> {
+ current_indent: usize,
+ has_value: bool,
+ indent: &'a [u8],
+}
+
+impl<'a> PrettyFormatter<'a> {
+ /// Construct a pretty printer formatter that defaults to using two spaces for indentation.
+ pub fn new() -> Self {
+ PrettyFormatter::with_indent(b" ")
+ }
+
+ /// Construct a pretty printer formatter that uses the `indent` string for indentation.
+ pub fn with_indent(indent: &'a [u8]) -> Self {
+ PrettyFormatter {
+ current_indent: 0,
+ has_value: false,
+ indent: indent,
+ }
+ }
+}
+
+impl<'a> Default for PrettyFormatter<'a> {
+ fn default() -> Self {
+ PrettyFormatter::new()
+ }
+}
+
+impl<'a> Formatter for PrettyFormatter<'a> {
+ #[inline]
+ fn begin_array<W: ?Sized>(&mut self, writer: &mut W) -> io::Result<()>
+ where
+ W: io::Write,
+ {
+ self.current_indent += 1;
+ self.has_value = false;
+ writer.write_all(b"[")
+ }
+
+ #[inline]
+ fn end_array<W: ?Sized>(&mut self, writer: &mut W) -> io::Result<()>
+ where
+ W: io::Write,
+ {
+ self.current_indent -= 1;
+
+ if self.has_value {
+ try!(writer.write_all(b"\n"));
+ try!(indent(writer, self.current_indent, self.indent));
+ }
+
+ writer.write_all(b"]")
+ }
+
+ #[inline]
+ fn begin_array_value<W: ?Sized>(&mut self, writer: &mut W, first: bool) -> io::Result<()>
+ where
+ W: io::Write,
+ {
+ if first {
+ try!(writer.write_all(b"\n"));
+ } else {
+ try!(writer.write_all(b",\n"));
+ }
+ try!(indent(writer, self.current_indent, self.indent));
+ Ok(())
+ }
+
+ #[inline]
+ fn end_array_value<W: ?Sized>(&mut self, _writer: &mut W) -> io::Result<()>
+ where
+ W: io::Write,
+ {
+ self.has_value = true;
+ Ok(())
+ }
+
+ #[inline]
+ fn begin_object<W: ?Sized>(&mut self, writer: &mut W) -> io::Result<()>
+ where
+ W: io::Write,
+ {
+ self.current_indent += 1;
+ self.has_value = false;
+ writer.write_all(b"{")
+ }
+
+ #[inline]
+ fn end_object<W: ?Sized>(&mut self, writer: &mut W) -> io::Result<()>
+ where
+ W: io::Write,
+ {
+ self.current_indent -= 1;
+
+ if self.has_value {
+ try!(writer.write_all(b"\n"));
+ try!(indent(writer, self.current_indent, self.indent));
+ }
+
+ writer.write_all(b"}")
+ }
+
+ #[inline]
+ fn begin_object_key<W: ?Sized>(&mut self, writer: &mut W, first: bool) -> io::Result<()>
+ where
+ W: io::Write,
+ {
+ if first {
+ try!(writer.write_all(b"\n"));
+ } else {
+ try!(writer.write_all(b",\n"));
+ }
+ indent(writer, self.current_indent, self.indent)
+ }
+
+ #[inline]
+ fn begin_object_value<W: ?Sized>(&mut self, writer: &mut W) -> io::Result<()>
+ where
+ W: io::Write,
+ {
+ writer.write_all(b": ")
+ }
+
+ #[inline]
+ fn end_object_value<W: ?Sized>(&mut self, _writer: &mut W) -> io::Result<()>
+ where
+ W: io::Write,
+ {
+ self.has_value = true;
+ Ok(())
+ }
+}
+
+fn format_escaped_str<W: ?Sized, F: ?Sized>(
+ writer: &mut W,
+ formatter: &mut F,
+ value: &str,
+) -> io::Result<()>
+where
+ W: io::Write,
+ F: Formatter,
+{
+ try!(formatter.begin_string(writer));
+ try!(format_escaped_str_contents(writer, formatter, value));
+ try!(formatter.end_string(writer));
+ Ok(())
+}
+
+fn format_escaped_str_contents<W: ?Sized, F: ?Sized>(
+ writer: &mut W,
+ formatter: &mut F,
+ value: &str,
+) -> io::Result<()>
+where
+ W: io::Write,
+ F: Formatter,
+{
+ let bytes = value.as_bytes();
+
+ let mut start = 0;
+
+ for (i, &byte) in bytes.iter().enumerate() {
+ let escape = ESCAPE[byte as usize];
+ if escape == 0 {
+ continue;
+ }
+
+ if start < i {
+ try!(formatter.write_string_fragment(writer, &value[start..i]));
+ }
+
+ let char_escape = CharEscape::from_escape_table(escape, byte);
+ try!(formatter.write_char_escape(writer, char_escape));
+
+ start = i + 1;
+ }
+
+ if start != bytes.len() {
+ try!(formatter.write_string_fragment(writer, &value[start..]));
+ }
+
+ Ok(())
+}
+
+const BB: u8 = b'b'; // \x08
+const TT: u8 = b't'; // \x09
+const NN: u8 = b'n'; // \x0A
+const FF: u8 = b'f'; // \x0C
+const RR: u8 = b'r'; // \x0D
+const QU: u8 = b'"'; // \x22
+const BS: u8 = b'\\'; // \x5C
+const U: u8 = b'u'; // \x00...\x1F except the ones above
+
+// Lookup table of escape sequences. A value of b'x' at index i means that byte
+// i is escaped as "\x" in JSON. A value of 0 means that byte i is not escaped.
+#[cfg_attr(rustfmt, rustfmt_skip)]
+static ESCAPE: [u8; 256] = [
+ // 1 2 3 4 5 6 7 8 9 A B C D E F
+ U, U, U, U, U, U, U, U, BB, TT, NN, U, FF, RR, U, U, // 0
+ U, U, U, U, U, U, U, U, U, U, U, U, U, U, U, U, // 1
+ 0, 0, QU, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, // 2
+ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, // 3
+ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, // 4
+ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, BS, 0, 0, 0, // 5
+ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, // 6
+ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, // 7
+ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, // 8
+ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, // 9
+ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, // A
+ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, // B
+ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, // C
+ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, // D
+ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, // E
+ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, // F
+];
+
+/// Serialize the given data structure as JSON into the IO stream.
+///
+/// # Errors
+///
+/// Serialization can fail if `T`'s implementation of `Serialize` decides to
+/// fail, or if `T` contains a map with non-string keys.
+#[inline]
+pub fn to_writer<W, T: ?Sized>(writer: W, value: &T) -> Result<()>
+where
+ W: io::Write,
+ T: ser::Serialize,
+{
+ let mut ser = Serializer::new(writer);
+ try!(value.serialize(&mut ser));
+ Ok(())
+}
+
+/// Serialize the given data structure as pretty-printed JSON into the IO
+/// stream.
+///
+/// # Errors
+///
+/// Serialization can fail if `T`'s implementation of `Serialize` decides to
+/// fail, or if `T` contains a map with non-string keys.
+#[inline]
+pub fn to_writer_pretty<W, T: ?Sized>(writer: W, value: &T) -> Result<()>
+where
+ W: io::Write,
+ T: ser::Serialize,
+{
+ let mut ser = Serializer::pretty(writer);
+ try!(value.serialize(&mut ser));
+ Ok(())
+}
+
+/// Serialize the given data structure as a JSON byte vector.
+///
+/// # Errors
+///
+/// Serialization can fail if `T`'s implementation of `Serialize` decides to
+/// fail, or if `T` contains a map with non-string keys.
+#[inline]
+pub fn to_vec<T: ?Sized>(value: &T) -> Result<Vec<u8>>
+where
+ T: ser::Serialize,
+{
+ let mut writer = Vec::with_capacity(128);
+ try!(to_writer(&mut writer, value));
+ Ok(writer)
+}
+
+/// Serialize the given data structure as a pretty-printed JSON byte vector.
+///
+/// # Errors
+///
+/// Serialization can fail if `T`'s implementation of `Serialize` decides to
+/// fail, or if `T` contains a map with non-string keys.
+#[inline]
+pub fn to_vec_pretty<T: ?Sized>(value: &T) -> Result<Vec<u8>>
+where
+ T: ser::Serialize,
+{
+ let mut writer = Vec::with_capacity(128);
+ try!(to_writer_pretty(&mut writer, value));
+ Ok(writer)
+}
+
+/// Serialize the given data structure as a String of JSON.
+///
+/// # Errors
+///
+/// Serialization can fail if `T`'s implementation of `Serialize` decides to
+/// fail, or if `T` contains a map with non-string keys.
+#[inline]
+pub fn to_string<T: ?Sized>(value: &T) -> Result<String>
+where
+ T: ser::Serialize,
+{
+ let vec = try!(to_vec(value));
+ let string = unsafe {
+ // We do not emit invalid UTF-8.
+ String::from_utf8_unchecked(vec)
+ };
+ Ok(string)
+}
+
+/// Serialize the given data structure as a pretty-printed String of JSON.
+///
+/// # Errors
+///
+/// Serialization can fail if `T`'s implementation of `Serialize` decides to
+/// fail, or if `T` contains a map with non-string keys.
+#[inline]
+pub fn to_string_pretty<T: ?Sized>(value: &T) -> Result<String>
+where
+ T: ser::Serialize,
+{
+ let vec = try!(to_vec_pretty(value));
+ let string = unsafe {
+ // We do not emit invalid UTF-8.
+ String::from_utf8_unchecked(vec)
+ };
+ Ok(string)
+}
+
+fn indent<W: ?Sized>(wr: &mut W, n: usize, s: &[u8]) -> io::Result<()>
+where
+ W: io::Write,
+{
+ for _ in 0..n {
+ try!(wr.write_all(s));
+ }
+
+ Ok(())
+}
new file mode 100644
--- /dev/null
+++ b/third_party/rust/serde_json/src/value/de.rs
@@ -0,0 +1,1376 @@
+// Copyright 2017 Serde Developers
+//
+// Licensed under the Apache License, Version 2.0 <LICENSE-APACHE or
+// http://www.apache.org/licenses/LICENSE-2.0> or the MIT license
+// <LICENSE-MIT or http://opensource.org/licenses/MIT>, at your
+// option. This file may not be copied, modified, or distributed
+// except according to those terms.
+
+use std::borrow::Cow;
+use std::fmt;
+use std::slice;
+use std::str;
+use std::vec;
+
+use serde;
+use serde::de::{
+ Deserialize, DeserializeSeed, EnumAccess, Expected, IntoDeserializer, MapAccess, SeqAccess,
+ Unexpected, VariantAccess, Visitor,
+};
+
+use error::Error;
+use map::Map;
+use number::Number;
+use value::Value;
+
+#[cfg(feature = "arbitrary_precision")]
+use serde::de;
+
+#[cfg(feature = "arbitrary_precision")]
+use number::{NumberFromString, SERDE_STRUCT_FIELD_NAME};
+
+impl<'de> Deserialize<'de> for Value {
+ #[inline]
+ fn deserialize<D>(deserializer: D) -> Result<Value, D::Error>
+ where
+ D: serde::Deserializer<'de>,
+ {
+ struct ValueVisitor;
+
+ impl<'de> Visitor<'de> for ValueVisitor {
+ type Value = Value;
+
+ fn expecting(&self, formatter: &mut fmt::Formatter) -> fmt::Result {
+ formatter.write_str("any valid JSON value")
+ }
+
+ #[inline]
+ fn visit_bool<E>(self, value: bool) -> Result<Value, E> {
+ Ok(Value::Bool(value))
+ }
+
+ #[inline]
+ fn visit_i64<E>(self, value: i64) -> Result<Value, E> {
+ Ok(Value::Number(value.into()))
+ }
+
+ #[inline]
+ fn visit_u64<E>(self, value: u64) -> Result<Value, E> {
+ Ok(Value::Number(value.into()))
+ }
+
+ #[inline]
+ fn visit_f64<E>(self, value: f64) -> Result<Value, E> {
+ Ok(Number::from_f64(value).map_or(Value::Null, Value::Number))
+ }
+
+ #[inline]
+ fn visit_str<E>(self, value: &str) -> Result<Value, E>
+ where
+ E: serde::de::Error,
+ {
+ self.visit_string(String::from(value))
+ }
+
+ #[inline]
+ fn visit_string<E>(self, value: String) -> Result<Value, E> {
+ Ok(Value::String(value))
+ }
+
+ #[inline]
+ fn visit_none<E>(self) -> Result<Value, E> {
+ Ok(Value::Null)
+ }
+
+ #[inline]
+ fn visit_some<D>(self, deserializer: D) -> Result<Value, D::Error>
+ where
+ D: serde::Deserializer<'de>,
+ {
+ Deserialize::deserialize(deserializer)
+ }
+
+ #[inline]
+ fn visit_unit<E>(self) -> Result<Value, E> {
+ Ok(Value::Null)
+ }
+
+ #[inline]
+ fn visit_seq<V>(self, mut visitor: V) -> Result<Value, V::Error>
+ where
+ V: SeqAccess<'de>,
+ {
+ let mut vec = Vec::new();
+
+ while let Some(elem) = try!(visitor.next_element()) {
+ vec.push(elem);
+ }
+
+ Ok(Value::Array(vec))
+ }
+
+ #[cfg(not(feature = "arbitrary_precision"))]
+ fn visit_map<V>(self, mut visitor: V) -> Result<Value, V::Error>
+ where
+ V: MapAccess<'de>,
+ {
+ let mut values = Map::new();
+
+ while let Some((key, value)) = try!(visitor.next_entry()) {
+ values.insert(key, value);
+ }
+
+ Ok(Value::Object(values))
+ }
+
+ #[cfg(feature = "arbitrary_precision")]
+ fn visit_map<V>(self, mut visitor: V) -> Result<Value, V::Error>
+ where
+ V: MapAccess<'de>,
+ {
+ let mut key = String::new();
+ let number = visitor.next_key_seed(NumberOrObject { key: &mut key })?;
+ match number {
+ Some(true) => {
+ let number: NumberFromString = visitor.next_value()?;
+ return Ok(Value::Number(number.value));
+ }
+ None => return Ok(Value::Object(Map::new())),
+ Some(false) => {}
+ }
+
+ let mut values = Map::new();
+
+ values.insert(key, try!(visitor.next_value()));
+ while let Some((key, value)) = try!(visitor.next_entry()) {
+ values.insert(key, value);
+ }
+
+ Ok(Value::Object(values))
+ }
+ }
+
+ deserializer.deserialize_any(ValueVisitor)
+ }
+}
+
+impl str::FromStr for Value {
+ type Err = Error;
+ fn from_str(s: &str) -> Result<Value, Error> {
+ super::super::de::from_str(s)
+ }
+}
+
+macro_rules! deserialize_prim_number {
+ ($method:ident) => {
+ #[cfg(not(feature = "arbitrary_precision"))]
+ fn $method<V>(self, visitor: V) -> Result<V::Value, Error>
+ where
+ V: Visitor<'de>,
+ {
+ match self {
+ Value::Number(n) => n.deserialize_any(visitor),
+ _ => Err(self.invalid_type(&visitor)),
+ }
+ }
+
+ #[cfg(feature = "arbitrary_precision")]
+ fn $method<V>(self, visitor: V) -> Result<V::Value, Error>
+ where
+ V: Visitor<'de>,
+ {
+ match self {
+ Value::Number(n) => n.$method(visitor),
+ _ => self.deserialize_any(visitor),
+ }
+ }
+ }
+}
+
+fn visit_array<'de, V>(array: Vec<Value>, visitor: V) -> Result<V::Value, Error>
+where
+ V: Visitor<'de>,
+{
+ let len = array.len();
+ let mut deserializer = SeqDeserializer::new(array);
+ let seq = try!(visitor.visit_seq(&mut deserializer));
+ let remaining = deserializer.iter.len();
+ if remaining == 0 {
+ Ok(seq)
+ } else {
+ Err(serde::de::Error::invalid_length(
+ len,
+ &"fewer elements in array",
+ ))
+ }
+}
+
+fn visit_object<'de, V>(object: Map<String, Value>, visitor: V) -> Result<V::Value, Error>
+where
+ V: Visitor<'de>,
+{
+ let len = object.len();
+ let mut deserializer = MapDeserializer::new(object);
+ let map = try!(visitor.visit_map(&mut deserializer));
+ let remaining = deserializer.iter.len();
+ if remaining == 0 {
+ Ok(map)
+ } else {
+ Err(serde::de::Error::invalid_length(
+ len,
+ &"fewer elements in map",
+ ))
+ }
+}
+
+impl<'de> serde::Deserializer<'de> for Value {
+ type Error = Error;
+
+ #[inline]
+ fn deserialize_any<V>(self, visitor: V) -> Result<V::Value, Error>
+ where
+ V: Visitor<'de>,
+ {
+ match self {
+ Value::Null => visitor.visit_unit(),
+ Value::Bool(v) => visitor.visit_bool(v),
+ Value::Number(n) => n.deserialize_any(visitor),
+ Value::String(v) => visitor.visit_string(v),
+ Value::Array(v) => visit_array(v, visitor),
+ Value::Object(v) => visit_object(v, visitor),
+ }
+ }
+
+ deserialize_prim_number!(deserialize_i8);
+ deserialize_prim_number!(deserialize_i16);
+ deserialize_prim_number!(deserialize_i32);
+ deserialize_prim_number!(deserialize_i64);
+ deserialize_prim_number!(deserialize_u8);
+ deserialize_prim_number!(deserialize_u16);
+ deserialize_prim_number!(deserialize_u32);
+ deserialize_prim_number!(deserialize_u64);
+ deserialize_prim_number!(deserialize_f32);
+ deserialize_prim_number!(deserialize_f64);
+
+ serde_if_integer128! {
+ deserialize_prim_number!(deserialize_i128);
+ deserialize_prim_number!(deserialize_u128);
+ }
+
+ #[inline]
+ fn deserialize_option<V>(self, visitor: V) -> Result<V::Value, Error>
+ where
+ V: Visitor<'de>,
+ {
+ match self {
+ Value::Null => visitor.visit_none(),
+ _ => visitor.visit_some(self),
+ }
+ }
+
+ #[inline]
+ fn deserialize_enum<V>(
+ self,
+ _name: &str,
+ _variants: &'static [&'static str],
+ visitor: V,
+ ) -> Result<V::Value, Error>
+ where
+ V: Visitor<'de>,
+ {
+ let (variant, value) = match self {
+ Value::Object(value) => {
+ let mut iter = value.into_iter();
+ let (variant, value) = match iter.next() {
+ Some(v) => v,
+ None => {
+ return Err(serde::de::Error::invalid_value(
+ Unexpected::Map,
+ &"map with a single key",
+ ));
+ }
+ };
+ // enums are encoded in json as maps with a single key:value pair
+ if iter.next().is_some() {
+ return Err(serde::de::Error::invalid_value(
+ Unexpected::Map,
+ &"map with a single key",
+ ));
+ }
+ (variant, Some(value))
+ }
+ Value::String(variant) => (variant, None),
+ other => {
+ return Err(serde::de::Error::invalid_type(
+ other.unexpected(),
+ &"string or map",
+ ));
+ }
+ };
+
+ visitor.visit_enum(EnumDeserializer {
+ variant: variant,
+ value: value,
+ })
+ }
+
+ #[inline]
+ fn deserialize_newtype_struct<V>(
+ self,
+ _name: &'static str,
+ visitor: V,
+ ) -> Result<V::Value, Self::Error>
+ where
+ V: Visitor<'de>,
+ {
+ visitor.visit_newtype_struct(self)
+ }
+
+ fn deserialize_bool<V>(self, visitor: V) -> Result<V::Value, Self::Error>
+ where
+ V: Visitor<'de>,
+ {
+ match self {
+ Value::Bool(v) => visitor.visit_bool(v),
+ _ => Err(self.invalid_type(&visitor)),
+ }
+ }
+
+ fn deserialize_char<V>(self, visitor: V) -> Result<V::Value, Self::Error>
+ where
+ V: Visitor<'de>,
+ {
+ self.deserialize_string(visitor)
+ }
+
+ fn deserialize_str<V>(self, visitor: V) -> Result<V::Value, Self::Error>
+ where
+ V: Visitor<'de>,
+ {
+ self.deserialize_string(visitor)
+ }
+
+ fn deserialize_string<V>(self, visitor: V) -> Result<V::Value, Self::Error>
+ where
+ V: Visitor<'de>,
+ {
+ match self {
+ Value::String(v) => visitor.visit_string(v),
+ _ => Err(self.invalid_type(&visitor)),
+ }
+ }
+
+ fn deserialize_bytes<V>(self, visitor: V) -> Result<V::Value, Self::Error>
+ where
+ V: Visitor<'de>,
+ {
+ self.deserialize_byte_buf(visitor)
+ }
+
+ fn deserialize_byte_buf<V>(self, visitor: V) -> Result<V::Value, Self::Error>
+ where
+ V: Visitor<'de>,
+ {
+ match self {
+ Value::String(v) => visitor.visit_string(v),
+ Value::Array(v) => visit_array(v, visitor),
+ _ => Err(self.invalid_type(&visitor)),
+ }
+ }
+
+ fn deserialize_unit<V>(self, visitor: V) -> Result<V::Value, Self::Error>
+ where
+ V: Visitor<'de>,
+ {
+ match self {
+ Value::Null => visitor.visit_unit(),
+ _ => Err(self.invalid_type(&visitor)),
+ }
+ }
+
+ fn deserialize_unit_struct<V>(
+ self,
+ _name: &'static str,
+ visitor: V,
+ ) -> Result<V::Value, Self::Error>
+ where
+ V: Visitor<'de>,
+ {
+ self.deserialize_unit(visitor)
+ }
+
+ fn deserialize_seq<V>(self, visitor: V) -> Result<V::Value, Self::Error>
+ where
+ V: Visitor<'de>,
+ {
+ match self {
+ Value::Array(v) => visit_array(v, visitor),
+ _ => Err(self.invalid_type(&visitor)),
+ }
+ }
+
+ fn deserialize_tuple<V>(self, _len: usize, visitor: V) -> Result<V::Value, Self::Error>
+ where
+ V: Visitor<'de>,
+ {
+ self.deserialize_seq(visitor)
+ }
+
+ fn deserialize_tuple_struct<V>(
+ self,
+ _name: &'static str,
+ _len: usize,
+ visitor: V,
+ ) -> Result<V::Value, Self::Error>
+ where
+ V: Visitor<'de>,
+ {
+ self.deserialize_seq(visitor)
+ }
+
+ fn deserialize_map<V>(self, visitor: V) -> Result<V::Value, Self::Error>
+ where
+ V: Visitor<'de>,
+ {
+ match self {
+ Value::Object(v) => visit_object(v, visitor),
+ _ => Err(self.invalid_type(&visitor)),
+ }
+ }
+
+ fn deserialize_struct<V>(
+ self,
+ _name: &'static str,
+ _fields: &'static [&'static str],
+ visitor: V,
+ ) -> Result<V::Value, Self::Error>
+ where
+ V: Visitor<'de>,
+ {
+ match self {
+ Value::Array(v) => visit_array(v, visitor),
+ Value::Object(v) => visit_object(v, visitor),
+ _ => Err(self.invalid_type(&visitor)),
+ }
+ }
+
+ fn deserialize_identifier<V>(self, visitor: V) -> Result<V::Value, Self::Error>
+ where
+ V: Visitor<'de>,
+ {
+ self.deserialize_string(visitor)
+ }
+
+ fn deserialize_ignored_any<V>(self, visitor: V) -> Result<V::Value, Self::Error>
+ where
+ V: Visitor<'de>,
+ {
+ drop(self);
+ visitor.visit_unit()
+ }
+}
+
+struct EnumDeserializer {
+ variant: String,
+ value: Option<Value>,
+}
+
+impl<'de> EnumAccess<'de> for EnumDeserializer {
+ type Error = Error;
+ type Variant = VariantDeserializer;
+
+ fn variant_seed<V>(self, seed: V) -> Result<(V::Value, VariantDeserializer), Error>
+ where
+ V: DeserializeSeed<'de>,
+ {
+ let variant = self.variant.into_deserializer();
+ let visitor = VariantDeserializer { value: self.value };
+ seed.deserialize(variant).map(|v| (v, visitor))
+ }
+}
+
+struct VariantDeserializer {
+ value: Option<Value>,
+}
+
+impl<'de> VariantAccess<'de> for VariantDeserializer {
+ type Error = Error;
+
+ fn unit_variant(self) -> Result<(), Error> {
+ match self.value {
+ Some(value) => Deserialize::deserialize(value),
+ None => Ok(()),
+ }
+ }
+
+ fn newtype_variant_seed<T>(self, seed: T) -> Result<T::Value, Error>
+ where
+ T: DeserializeSeed<'de>,
+ {
+ match self.value {
+ Some(value) => seed.deserialize(value),
+ None => Err(serde::de::Error::invalid_type(
+ Unexpected::UnitVariant,
+ &"newtype variant",
+ )),
+ }
+ }
+
+ fn tuple_variant<V>(self, _len: usize, visitor: V) -> Result<V::Value, Error>
+ where
+ V: Visitor<'de>,
+ {
+ match self.value {
+ Some(Value::Array(v)) => {
+ serde::Deserializer::deserialize_any(SeqDeserializer::new(v), visitor)
+ }
+ Some(other) => Err(serde::de::Error::invalid_type(
+ other.unexpected(),
+ &"tuple variant",
+ )),
+ None => Err(serde::de::Error::invalid_type(
+ Unexpected::UnitVariant,
+ &"tuple variant",
+ )),
+ }
+ }
+
+ fn struct_variant<V>(
+ self,
+ _fields: &'static [&'static str],
+ visitor: V,
+ ) -> Result<V::Value, Error>
+ where
+ V: Visitor<'de>,
+ {
+ match self.value {
+ Some(Value::Object(v)) => {
+ serde::Deserializer::deserialize_any(MapDeserializer::new(v), visitor)
+ }
+ Some(other) => Err(serde::de::Error::invalid_type(
+ other.unexpected(),
+ &"struct variant",
+ )),
+ _ => Err(serde::de::Error::invalid_type(
+ Unexpected::UnitVariant,
+ &"struct variant",
+ )),
+ }
+ }
+}
+
+struct SeqDeserializer {
+ iter: vec::IntoIter<Value>,
+}
+
+impl SeqDeserializer {
+ fn new(vec: Vec<Value>) -> Self {
+ SeqDeserializer {
+ iter: vec.into_iter(),
+ }
+ }
+}
+
+impl<'de> serde::Deserializer<'de> for SeqDeserializer {
+ type Error = Error;
+
+ #[inline]
+ fn deserialize_any<V>(mut self, visitor: V) -> Result<V::Value, Error>
+ where
+ V: Visitor<'de>,
+ {
+ let len = self.iter.len();
+ if len == 0 {
+ visitor.visit_unit()
+ } else {
+ let ret = try!(visitor.visit_seq(&mut self));
+ let remaining = self.iter.len();
+ if remaining == 0 {
+ Ok(ret)
+ } else {
+ Err(serde::de::Error::invalid_length(
+ len,
+ &"fewer elements in array",
+ ))
+ }
+ }
+ }
+
+ forward_to_deserialize_any! {
+ bool i8 i16 i32 i64 i128 u8 u16 u32 u64 u128 f32 f64 char str string
+ bytes byte_buf option unit unit_struct newtype_struct seq tuple
+ tuple_struct map struct enum identifier ignored_any
+ }
+}
+
+impl<'de> SeqAccess<'de> for SeqDeserializer {
+ type Error = Error;
+
+ fn next_element_seed<T>(&mut self, seed: T) -> Result<Option<T::Value>, Error>
+ where
+ T: DeserializeSeed<'de>,
+ {
+ match self.iter.next() {
+ Some(value) => seed.deserialize(value).map(Some),
+ None => Ok(None),
+ }
+ }
+
+ fn size_hint(&self) -> Option<usize> {
+ match self.iter.size_hint() {
+ (lower, Some(upper)) if lower == upper => Some(upper),
+ _ => None,
+ }
+ }
+}
+
+struct MapDeserializer {
+ iter: <Map<String, Value> as IntoIterator>::IntoIter,
+ value: Option<Value>,
+}
+
+impl MapDeserializer {
+ fn new(map: Map<String, Value>) -> Self {
+ MapDeserializer {
+ iter: map.into_iter(),
+ value: None,
+ }
+ }
+}
+
+impl<'de> MapAccess<'de> for MapDeserializer {
+ type Error = Error;
+
+ fn next_key_seed<T>(&mut self, seed: T) -> Result<Option<T::Value>, Error>
+ where
+ T: DeserializeSeed<'de>,
+ {
+ match self.iter.next() {
+ Some((key, value)) => {
+ self.value = Some(value);
+ let key_de = MapKeyDeserializer {
+ key: Cow::Owned(key),
+ };
+ seed.deserialize(key_de).map(Some)
+ }
+ None => Ok(None),
+ }
+ }
+
+ fn next_value_seed<T>(&mut self, seed: T) -> Result<T::Value, Error>
+ where
+ T: DeserializeSeed<'de>,
+ {
+ match self.value.take() {
+ Some(value) => seed.deserialize(value),
+ None => Err(serde::de::Error::custom("value is missing")),
+ }
+ }
+
+ fn size_hint(&self) -> Option<usize> {
+ match self.iter.size_hint() {
+ (lower, Some(upper)) if lower == upper => Some(upper),
+ _ => None,
+ }
+ }
+}
+
+impl<'de> serde::Deserializer<'de> for MapDeserializer {
+ type Error = Error;
+
+ #[inline]
+ fn deserialize_any<V>(self, visitor: V) -> Result<V::Value, Error>
+ where
+ V: Visitor<'de>,
+ {
+ visitor.visit_map(self)
+ }
+
+ forward_to_deserialize_any! {
+ bool i8 i16 i32 i64 i128 u8 u16 u32 u64 u128 f32 f64 char str string
+ bytes byte_buf option unit unit_struct newtype_struct seq tuple
+ tuple_struct map struct enum identifier ignored_any
+ }
+}
+
+macro_rules! deserialize_value_ref_number {
+ ($method:ident) => {
+ #[cfg(not(feature = "arbitrary_precision"))]
+ fn $method<V>(self, visitor: V) -> Result<V::Value, Error>
+ where
+ V: Visitor<'de>,
+ {
+ match *self {
+ Value::Number(ref n) => n.deserialize_any(visitor),
+ _ => Err(self.invalid_type(&visitor)),
+ }
+ }
+
+ #[cfg(feature = "arbitrary_precision")]
+ fn $method<V>(self, visitor: V) -> Result<V::Value, Error>
+ where
+ V: Visitor<'de>,
+ {
+ match *self {
+ Value::Number(ref n) => n.$method(visitor),
+ _ => self.deserialize_any(visitor),
+ }
+ }
+ }
+}
+
+fn visit_array_ref<'de, V>(array: &'de [Value], visitor: V) -> Result<V::Value, Error>
+where
+ V: Visitor<'de>,
+{
+ let len = array.len();
+ let mut deserializer = SeqRefDeserializer::new(array);
+ let seq = try!(visitor.visit_seq(&mut deserializer));
+ let remaining = deserializer.iter.len();
+ if remaining == 0 {
+ Ok(seq)
+ } else {
+ Err(serde::de::Error::invalid_length(
+ len,
+ &"fewer elements in array",
+ ))
+ }
+}
+
+fn visit_object_ref<'de, V>(object: &'de Map<String, Value>, visitor: V) -> Result<V::Value, Error>
+where
+ V: Visitor<'de>,
+{
+ let len = object.len();
+ let mut deserializer = MapRefDeserializer::new(object);
+ let map = try!(visitor.visit_map(&mut deserializer));
+ let remaining = deserializer.iter.len();
+ if remaining == 0 {
+ Ok(map)
+ } else {
+ Err(serde::de::Error::invalid_length(
+ len,
+ &"fewer elements in map",
+ ))
+ }
+}
+
+impl<'de> serde::Deserializer<'de> for &'de Value {
+ type Error = Error;
+
+ fn deserialize_any<V>(self, visitor: V) -> Result<V::Value, Error>
+ where
+ V: Visitor<'de>,
+ {
+ match *self {
+ Value::Null => visitor.visit_unit(),
+ Value::Bool(v) => visitor.visit_bool(v),
+ Value::Number(ref n) => n.deserialize_any(visitor),
+ Value::String(ref v) => visitor.visit_borrowed_str(v),
+ Value::Array(ref v) => visit_array_ref(v, visitor),
+ Value::Object(ref v) => visit_object_ref(v, visitor),
+ }
+ }
+
+ deserialize_value_ref_number!(deserialize_i8);
+ deserialize_value_ref_number!(deserialize_i16);
+ deserialize_value_ref_number!(deserialize_i32);
+ deserialize_value_ref_number!(deserialize_i64);
+ deserialize_value_ref_number!(deserialize_u8);
+ deserialize_value_ref_number!(deserialize_u16);
+ deserialize_value_ref_number!(deserialize_u32);
+ deserialize_value_ref_number!(deserialize_u64);
+ deserialize_value_ref_number!(deserialize_f32);
+ deserialize_value_ref_number!(deserialize_f64);
+
+ serde_if_integer128! {
+ deserialize_prim_number!(deserialize_i128);
+ deserialize_prim_number!(deserialize_u128);
+ }
+
+ fn deserialize_option<V>(self, visitor: V) -> Result<V::Value, Error>
+ where
+ V: Visitor<'de>,
+ {
+ match *self {
+ Value::Null => visitor.visit_none(),
+ _ => visitor.visit_some(self),
+ }
+ }
+
+ fn deserialize_enum<V>(
+ self,
+ _name: &str,
+ _variants: &'static [&'static str],
+ visitor: V,
+ ) -> Result<V::Value, Error>
+ where
+ V: Visitor<'de>,
+ {
+ let (variant, value) = match *self {
+ Value::Object(ref value) => {
+ let mut iter = value.into_iter();
+ let (variant, value) = match iter.next() {
+ Some(v) => v,
+ None => {
+ return Err(serde::de::Error::invalid_value(
+ Unexpected::Map,
+ &"map with a single key",
+ ));
+ }
+ };
+ // enums are encoded in json as maps with a single key:value pair
+ if iter.next().is_some() {
+ return Err(serde::de::Error::invalid_value(
+ Unexpected::Map,
+ &"map with a single key",
+ ));
+ }
+ (variant, Some(value))
+ }
+ Value::String(ref variant) => (variant, None),
+ ref other => {
+ return Err(serde::de::Error::invalid_type(
+ other.unexpected(),
+ &"string or map",
+ ));
+ }
+ };
+
+ visitor.visit_enum(EnumRefDeserializer {
+ variant: variant,
+ value: value,
+ })
+ }
+
+ #[inline]
+ fn deserialize_newtype_struct<V>(
+ self,
+ _name: &'static str,
+ visitor: V,
+ ) -> Result<V::Value, Self::Error>
+ where
+ V: Visitor<'de>,
+ {
+ visitor.visit_newtype_struct(self)
+ }
+
+ fn deserialize_bool<V>(self, visitor: V) -> Result<V::Value, Self::Error>
+ where
+ V: Visitor<'de>,
+ {
+ match *self {
+ Value::Bool(v) => visitor.visit_bool(v),
+ _ => Err(self.invalid_type(&visitor)),
+ }
+ }
+
+ fn deserialize_char<V>(self, visitor: V) -> Result<V::Value, Self::Error>
+ where
+ V: Visitor<'de>,
+ {
+ self.deserialize_str(visitor)
+ }
+
+ fn deserialize_str<V>(self, visitor: V) -> Result<V::Value, Self::Error>
+ where
+ V: Visitor<'de>,
+ {
+ match *self {
+ Value::String(ref v) => visitor.visit_borrowed_str(v),
+ _ => Err(self.invalid_type(&visitor)),
+ }
+ }
+
+ fn deserialize_string<V>(self, visitor: V) -> Result<V::Value, Self::Error>
+ where
+ V: Visitor<'de>,
+ {
+ self.deserialize_str(visitor)
+ }
+
+ fn deserialize_bytes<V>(self, visitor: V) -> Result<V::Value, Self::Error>
+ where
+ V: Visitor<'de>,
+ {
+ match *self {
+ Value::String(ref v) => visitor.visit_borrowed_str(v),
+ Value::Array(ref v) => visit_array_ref(v, visitor),
+ _ => Err(self.invalid_type(&visitor)),
+ }
+ }
+
+ fn deserialize_byte_buf<V>(self, visitor: V) -> Result<V::Value, Self::Error>
+ where
+ V: Visitor<'de>,
+ {
+ self.deserialize_bytes(visitor)
+ }
+
+ fn deserialize_unit<V>(self, visitor: V) -> Result<V::Value, Self::Error>
+ where
+ V: Visitor<'de>,
+ {
+ match *self {
+ Value::Null => visitor.visit_unit(),
+ _ => Err(self.invalid_type(&visitor)),
+ }
+ }
+
+ fn deserialize_unit_struct<V>(
+ self,
+ _name: &'static str,
+ visitor: V,
+ ) -> Result<V::Value, Self::Error>
+ where
+ V: Visitor<'de>,
+ {
+ self.deserialize_unit(visitor)
+ }
+
+ fn deserialize_seq<V>(self, visitor: V) -> Result<V::Value, Self::Error>
+ where
+ V: Visitor<'de>,
+ {
+ match *self {
+ Value::Array(ref v) => visit_array_ref(v, visitor),
+ _ => Err(self.invalid_type(&visitor)),
+ }
+ }
+
+ fn deserialize_tuple<V>(self, _len: usize, visitor: V) -> Result<V::Value, Self::Error>
+ where
+ V: Visitor<'de>,
+ {
+ self.deserialize_seq(visitor)
+ }
+
+ fn deserialize_tuple_struct<V>(
+ self,
+ _name: &'static str,
+ _len: usize,
+ visitor: V,
+ ) -> Result<V::Value, Self::Error>
+ where
+ V: Visitor<'de>,
+ {
+ self.deserialize_seq(visitor)
+ }
+
+ fn deserialize_map<V>(self, visitor: V) -> Result<V::Value, Self::Error>
+ where
+ V: Visitor<'de>,
+ {
+ match *self {
+ Value::Object(ref v) => visit_object_ref(v, visitor),
+ _ => Err(self.invalid_type(&visitor)),
+ }
+ }
+
+ fn deserialize_struct<V>(
+ self,
+ _name: &'static str,
+ _fields: &'static [&'static str],
+ visitor: V,
+ ) -> Result<V::Value, Self::Error>
+ where
+ V: Visitor<'de>,
+ {
+ match *self {
+ Value::Array(ref v) => visit_array_ref(v, visitor),
+ Value::Object(ref v) => visit_object_ref(v, visitor),
+ _ => Err(self.invalid_type(&visitor)),
+ }
+ }
+
+ fn deserialize_identifier<V>(self, visitor: V) -> Result<V::Value, Self::Error>
+ where
+ V: Visitor<'de>,
+ {
+ self.deserialize_str(visitor)
+ }
+
+ fn deserialize_ignored_any<V>(self, visitor: V) -> Result<V::Value, Self::Error>
+ where
+ V: Visitor<'de>,
+ {
+ visitor.visit_unit()
+ }
+}
+
+struct EnumRefDeserializer<'de> {
+ variant: &'de str,
+ value: Option<&'de Value>,
+}
+
+impl<'de> EnumAccess<'de> for EnumRefDeserializer<'de> {
+ type Error = Error;
+ type Variant = VariantRefDeserializer<'de>;
+
+ fn variant_seed<V>(self, seed: V) -> Result<(V::Value, Self::Variant), Error>
+ where
+ V: DeserializeSeed<'de>,
+ {
+ let variant = self.variant.into_deserializer();
+ let visitor = VariantRefDeserializer { value: self.value };
+ seed.deserialize(variant).map(|v| (v, visitor))
+ }
+}
+
+struct VariantRefDeserializer<'de> {
+ value: Option<&'de Value>,
+}
+
+impl<'de> VariantAccess<'de> for VariantRefDeserializer<'de> {
+ type Error = Error;
+
+ fn unit_variant(self) -> Result<(), Error> {
+ match self.value {
+ Some(value) => Deserialize::deserialize(value),
+ None => Ok(()),
+ }
+ }
+
+ fn newtype_variant_seed<T>(self, seed: T) -> Result<T::Value, Error>
+ where
+ T: DeserializeSeed<'de>,
+ {
+ match self.value {
+ Some(value) => seed.deserialize(value),
+ None => Err(serde::de::Error::invalid_type(
+ Unexpected::UnitVariant,
+ &"newtype variant",
+ )),
+ }
+ }
+
+ fn tuple_variant<V>(self, _len: usize, visitor: V) -> Result<V::Value, Error>
+ where
+ V: Visitor<'de>,
+ {
+ match self.value {
+ Some(&Value::Array(ref v)) => {
+ serde::Deserializer::deserialize_any(SeqRefDeserializer::new(v), visitor)
+ }
+ Some(other) => Err(serde::de::Error::invalid_type(
+ other.unexpected(),
+ &"tuple variant",
+ )),
+ None => Err(serde::de::Error::invalid_type(
+ Unexpected::UnitVariant,
+ &"tuple variant",
+ )),
+ }
+ }
+
+ fn struct_variant<V>(
+ self,
+ _fields: &'static [&'static str],
+ visitor: V,
+ ) -> Result<V::Value, Error>
+ where
+ V: Visitor<'de>,
+ {
+ match self.value {
+ Some(&Value::Object(ref v)) => {
+ serde::Deserializer::deserialize_any(MapRefDeserializer::new(v), visitor)
+ }
+ Some(other) => Err(serde::de::Error::invalid_type(
+ other.unexpected(),
+ &"struct variant",
+ )),
+ _ => Err(serde::de::Error::invalid_type(
+ Unexpected::UnitVariant,
+ &"struct variant",
+ )),
+ }
+ }
+}
+
+struct SeqRefDeserializer<'de> {
+ iter: slice::Iter<'de, Value>,
+}
+
+impl<'de> SeqRefDeserializer<'de> {
+ fn new(slice: &'de [Value]) -> Self {
+ SeqRefDeserializer { iter: slice.iter() }
+ }
+}
+
+impl<'de> serde::Deserializer<'de> for SeqRefDeserializer<'de> {
+ type Error = Error;
+
+ #[inline]
+ fn deserialize_any<V>(mut self, visitor: V) -> Result<V::Value, Error>
+ where
+ V: Visitor<'de>,
+ {
+ let len = self.iter.len();
+ if len == 0 {
+ visitor.visit_unit()
+ } else {
+ let ret = try!(visitor.visit_seq(&mut self));
+ let remaining = self.iter.len();
+ if remaining == 0 {
+ Ok(ret)
+ } else {
+ Err(serde::de::Error::invalid_length(
+ len,
+ &"fewer elements in array",
+ ))
+ }
+ }
+ }
+
+ forward_to_deserialize_any! {
+ bool i8 i16 i32 i64 i128 u8 u16 u32 u64 u128 f32 f64 char str string
+ bytes byte_buf option unit unit_struct newtype_struct seq tuple
+ tuple_struct map struct enum identifier ignored_any
+ }
+}
+
+impl<'de> SeqAccess<'de> for SeqRefDeserializer<'de> {
+ type Error = Error;
+
+ fn next_element_seed<T>(&mut self, seed: T) -> Result<Option<T::Value>, Error>
+ where
+ T: DeserializeSeed<'de>,
+ {
+ match self.iter.next() {
+ Some(value) => seed.deserialize(value).map(Some),
+ None => Ok(None),
+ }
+ }
+
+ fn size_hint(&self) -> Option<usize> {
+ match self.iter.size_hint() {
+ (lower, Some(upper)) if lower == upper => Some(upper),
+ _ => None,
+ }
+ }
+}
+
+struct MapRefDeserializer<'de> {
+ iter: <&'de Map<String, Value> as IntoIterator>::IntoIter,
+ value: Option<&'de Value>,
+}
+
+impl<'de> MapRefDeserializer<'de> {
+ fn new(map: &'de Map<String, Value>) -> Self {
+ MapRefDeserializer {
+ iter: map.into_iter(),
+ value: None,
+ }
+ }
+}
+
+impl<'de> MapAccess<'de> for MapRefDeserializer<'de> {
+ type Error = Error;
+
+ fn next_key_seed<T>(&mut self, seed: T) -> Result<Option<T::Value>, Error>
+ where
+ T: DeserializeSeed<'de>,
+ {
+ match self.iter.next() {
+ Some((key, value)) => {
+ self.value = Some(value);
+ let key_de = MapKeyDeserializer {
+ key: Cow::Borrowed(&**key),
+ };
+ seed.deserialize(key_de).map(Some)
+ }
+ None => Ok(None),
+ }
+ }
+
+ fn next_value_seed<T>(&mut self, seed: T) -> Result<T::Value, Error>
+ where
+ T: DeserializeSeed<'de>,
+ {
+ match self.value.take() {
+ Some(value) => seed.deserialize(value),
+ None => Err(serde::de::Error::custom("value is missing")),
+ }
+ }
+
+ fn size_hint(&self) -> Option<usize> {
+ match self.iter.size_hint() {
+ (lower, Some(upper)) if lower == upper => Some(upper),
+ _ => None,
+ }
+ }
+}
+
+impl<'de> serde::Deserializer<'de> for MapRefDeserializer<'de> {
+ type Error = Error;
+
+ #[inline]
+ fn deserialize_any<V>(self, visitor: V) -> Result<V::Value, Error>
+ where
+ V: Visitor<'de>,
+ {
+ visitor.visit_map(self)
+ }
+
+ forward_to_deserialize_any! {
+ bool i8 i16 i32 i64 i128 u8 u16 u32 u64 u128 f32 f64 char str string
+ bytes byte_buf option unit unit_struct newtype_struct seq tuple
+ tuple_struct map struct enum identifier ignored_any
+ }
+}
+
+struct MapKeyDeserializer<'de> {
+ key: Cow<'de, str>,
+}
+
+macro_rules! deserialize_integer_key {
+ ($method:ident => $visit:ident) => {
+ fn $method<V>(self, visitor: V) -> Result<V::Value, Error>
+ where
+ V: Visitor<'de>,
+ {
+ match (self.key.parse(), self.key) {
+ (Ok(integer), _) => visitor.$visit(integer),
+ (Err(_), Cow::Borrowed(s)) => visitor.visit_borrowed_str(s),
+ (Err(_), Cow::Owned(s)) => visitor.visit_string(s),
+ }
+ }
+ }
+}
+
+impl<'de> serde::Deserializer<'de> for MapKeyDeserializer<'de> {
+ type Error = Error;
+
+ fn deserialize_any<V>(self, visitor: V) -> Result<V::Value, Error>
+ where
+ V: Visitor<'de>,
+ {
+ self.key.into_deserializer().deserialize_any(visitor)
+ }
+
+ deserialize_integer_key!(deserialize_i8 => visit_i8);
+ deserialize_integer_key!(deserialize_i16 => visit_i16);
+ deserialize_integer_key!(deserialize_i32 => visit_i32);
+ deserialize_integer_key!(deserialize_i64 => visit_i64);
+ deserialize_integer_key!(deserialize_u8 => visit_u8);
+ deserialize_integer_key!(deserialize_u16 => visit_u16);
+ deserialize_integer_key!(deserialize_u32 => visit_u32);
+ deserialize_integer_key!(deserialize_u64 => visit_u64);
+
+ serde_if_integer128! {
+ deserialize_integer_key!(deserialize_i128 => visit_i128);
+ deserialize_integer_key!(deserialize_u128 => visit_u128);
+ }
+
+ #[inline]
+ fn deserialize_option<V>(self, visitor: V) -> Result<V::Value, Error>
+ where
+ V: Visitor<'de>,
+ {
+ // Map keys cannot be null.
+ visitor.visit_some(self)
+ }
+
+ #[inline]
+ fn deserialize_newtype_struct<V>(
+ self,
+ _name: &'static str,
+ visitor: V,
+ ) -> Result<V::Value, Error>
+ where
+ V: Visitor<'de>,
+ {
+ visitor.visit_newtype_struct(self)
+ }
+
+ fn deserialize_enum<V>(
+ self,
+ name: &'static str,
+ variants: &'static [&'static str],
+ visitor: V,
+ ) -> Result<V::Value, Error>
+ where
+ V: Visitor<'de>,
+ {
+ self.key
+ .into_deserializer()
+ .deserialize_enum(name, variants, visitor)
+ }
+
+ forward_to_deserialize_any! {
+ bool f32 f64 char str string bytes byte_buf unit unit_struct seq tuple
+ tuple_struct map struct identifier ignored_any
+ }
+}
+
+#[cfg(feature = "arbitrary_precision")]
+struct NumberOrObject<'a> {
+ key: &'a mut String,
+}
+
+#[cfg(feature = "arbitrary_precision")]
+impl<'a, 'de> DeserializeSeed<'de> for NumberOrObject<'a> {
+ type Value = bool;
+
+ fn deserialize<D>(self, deserializer: D) -> Result<Self::Value, D::Error>
+ where
+ D: serde::Deserializer<'de>,
+ {
+ deserializer.deserialize_any(self)
+ }
+}
+
+#[cfg(feature = "arbitrary_precision")]
+impl<'a, 'de> Visitor<'de> for NumberOrObject<'a> {
+ type Value = bool;
+
+ fn expecting(&self, formatter: &mut fmt::Formatter) -> fmt::Result {
+ formatter.write_str("a string key")
+ }
+
+ fn visit_str<E>(self, s: &str) -> Result<bool, E>
+ where
+ E: de::Error,
+ {
+ if s == SERDE_STRUCT_FIELD_NAME {
+ Ok(true)
+ } else {
+ self.key.push_str(s);
+ Ok(false)
+ }
+ }
+
+ fn visit_string<E>(self, s: String) -> Result<bool, E>
+ where
+ E: de::Error,
+ {
+ if s == SERDE_STRUCT_FIELD_NAME {
+ Ok(true)
+ } else {
+ *self.key = s;
+ Ok(false)
+ }
+ }
+}
+
+impl Value {
+ #[cold]
+ fn invalid_type<E>(&self, exp: &Expected) -> E
+ where
+ E: serde::de::Error,
+ {
+ serde::de::Error::invalid_type(self.unexpected(), exp)
+ }
+
+ #[cold]
+ fn unexpected(&self) -> Unexpected {
+ match *self {
+ Value::Null => Unexpected::Unit,
+ Value::Bool(b) => Unexpected::Bool(b),
+ Value::Number(ref n) => n.unexpected(),
+ Value::String(ref s) => Unexpected::Str(s),
+ Value::Array(_) => Unexpected::Seq,
+ Value::Object(_) => Unexpected::Map,
+ }
+ }
+}
new file mode 100644
--- /dev/null
+++ b/third_party/rust/serde_json/src/value/from.rs
@@ -0,0 +1,266 @@
+// Copyright 2017 Serde Developers
+//
+// Licensed under the Apache License, Version 2.0 <LICENSE-APACHE or
+// http://www.apache.org/licenses/LICENSE-2.0> or the MIT license
+// <LICENSE-MIT or http://opensource.org/licenses/MIT>, at your
+// option. This file may not be copied, modified, or distributed
+// except according to those terms.
+
+use std::borrow::Cow;
+
+use super::Value;
+use map::Map;
+use number::Number;
+
+macro_rules! from_integer {
+ ($($ty:ident)*) => {
+ $(
+ impl From<$ty> for Value {
+ fn from(n: $ty) -> Self {
+ Value::Number(n.into())
+ }
+ }
+ )*
+ };
+}
+
+from_integer! {
+ i8 i16 i32 i64 isize
+ u8 u16 u32 u64 usize
+}
+
+impl From<f32> for Value {
+ /// Convert 32-bit floating point number to `Value`
+ ///
+ /// # Examples
+ ///
+ /// ```rust
+ /// # extern crate serde_json;
+ /// #
+ /// # fn main() {
+ /// use serde_json::Value;
+ ///
+ /// let f: f32 = 13.37;
+ /// let x: Value = f.into();
+ /// # }
+ /// ```
+ fn from(f: f32) -> Self {
+ From::from(f as f64)
+ }
+}
+
+impl From<f64> for Value {
+ /// Convert 64-bit floating point number to `Value`
+ ///
+ /// # Examples
+ ///
+ /// ```rust
+ /// # extern crate serde_json;
+ /// #
+ /// # fn main() {
+ /// use serde_json::Value;
+ ///
+ /// let f: f64 = 13.37;
+ /// let x: Value = f.into();
+ /// # }
+ /// ```
+ fn from(f: f64) -> Self {
+ Number::from_f64(f).map_or(Value::Null, Value::Number)
+ }
+}
+
+impl From<bool> for Value {
+ /// Convert boolean to `Value`
+ ///
+ /// # Examples
+ ///
+ /// ```rust
+ /// # extern crate serde_json;
+ /// #
+ /// # fn main() {
+ /// use serde_json::Value;
+ ///
+ /// let b = false;
+ /// let x: Value = b.into();
+ /// # }
+ /// ```
+ fn from(f: bool) -> Self {
+ Value::Bool(f)
+ }
+}
+
+impl From<String> for Value {
+ /// Convert `String` to `Value`
+ ///
+ /// # Examples
+ ///
+ /// ```rust
+ /// # extern crate serde_json;
+ /// #
+ /// # fn main() {
+ /// use serde_json::Value;
+ ///
+ /// let s: String = "lorem".to_string();
+ /// let x: Value = s.into();
+ /// # }
+ /// ```
+ fn from(f: String) -> Self {
+ Value::String(f)
+ }
+}
+
+impl<'a> From<&'a str> for Value {
+ /// Convert string slice to `Value`
+ ///
+ /// # Examples
+ ///
+ /// ```rust
+ /// # extern crate serde_json;
+ /// #
+ /// # fn main() {
+ /// use serde_json::Value;
+ ///
+ /// let s: &str = "lorem";
+ /// let x: Value = s.into();
+ /// # }
+ /// ```
+ fn from(f: &str) -> Self {
+ Value::String(f.to_string())
+ }
+}
+
+impl<'a> From<Cow<'a, str>> for Value {
+ /// Convert copy-on-write string to `Value`
+ ///
+ /// # Examples
+ ///
+ /// ```rust
+ /// # extern crate serde_json;
+ /// #
+ /// # fn main() {
+ /// use serde_json::Value;
+ /// use std::borrow::Cow;
+ ///
+ /// let s: Cow<str> = Cow::Borrowed("lorem");
+ /// let x: Value = s.into();
+ /// # }
+ /// ```
+ ///
+ /// ```rust
+ /// # extern crate serde_json;
+ /// #
+ /// # fn main() {
+ /// use serde_json::Value;
+ /// use std::borrow::Cow;
+ ///
+ /// let s: Cow<str> = Cow::Owned("lorem".to_string());
+ /// let x: Value = s.into();
+ /// # }
+ /// ```
+ fn from(f: Cow<'a, str>) -> Self {
+ Value::String(f.into_owned())
+ }
+}
+
+impl From<Map<String, Value>> for Value {
+ /// Convert map (with string keys) to `Value`
+ ///
+ /// # Examples
+ ///
+ /// ```rust
+ /// # extern crate serde_json;
+ /// #
+ /// # fn main() {
+ /// use serde_json::{Map, Value};
+ ///
+ /// let mut m = Map::new();
+ /// m.insert("Lorem".to_string(), "ipsum".into());
+ /// let x: Value = m.into();
+ /// # }
+ /// ```
+ fn from(f: Map<String, Value>) -> Self {
+ Value::Object(f)
+ }
+}
+
+impl<T: Into<Value>> From<Vec<T>> for Value {
+ /// Convert a `Vec` to `Value`
+ ///
+ /// # Examples
+ ///
+ /// ```rust
+ /// # extern crate serde_json;
+ /// #
+ /// # fn main() {
+ /// use serde_json::Value;
+ ///
+ /// let v = vec!["lorem", "ipsum", "dolor"];
+ /// let x: Value = v.into();
+ /// # }
+ /// ```
+ fn from(f: Vec<T>) -> Self {
+ Value::Array(f.into_iter().map(Into::into).collect())
+ }
+}
+
+impl<'a, T: Clone + Into<Value>> From<&'a [T]> for Value {
+ /// Convert a slice to `Value`
+ ///
+ /// # Examples
+ ///
+ /// ```rust
+ /// # extern crate serde_json;
+ /// #
+ /// # fn main() {
+ /// use serde_json::Value;
+ ///
+ /// let v: &[&str] = &["lorem", "ipsum", "dolor"];
+ /// let x: Value = v.into();
+ /// # }
+ /// ```
+ fn from(f: &'a [T]) -> Self {
+ Value::Array(f.into_iter().cloned().map(Into::into).collect())
+ }
+}
+
+impl<T: Into<Value>> ::std::iter::FromIterator<T> for Value {
+ /// Convert an iteratable type to a `Value`
+ ///
+ /// # Examples
+ ///
+ /// ```rust
+ /// # extern crate serde_json;
+ /// #
+ /// # fn main() {
+ /// use serde_json::Value;
+ ///
+ /// let v = std::iter::repeat(42).take(5);
+ /// let x: Value = v.collect();
+ /// # }
+ /// ```
+ ///
+ /// ```rust
+ /// # extern crate serde_json;
+ /// #
+ /// # fn main() {
+ /// use serde_json::Value;
+ ///
+ /// let v: Vec<_> = vec!["lorem", "ipsum", "dolor"];
+ /// let x: Value = v.into_iter().collect();
+ /// # }
+ /// ```
+ ///
+ /// ```rust
+ /// # extern crate serde_json;
+ /// #
+ /// # fn main() {
+ /// use std::iter::FromIterator;
+ /// use serde_json::Value;
+ ///
+ /// let x: Value = Value::from_iter(vec!["lorem", "ipsum", "dolor"]);
+ /// # }
+ /// ```
+ fn from_iter<I: IntoIterator<Item = T>>(iter: I) -> Self {
+ Value::Array(iter.into_iter().map(Into::into).collect())
+ }
+}
new file mode 100644
--- /dev/null
+++ b/third_party/rust/serde_json/src/value/index.rs
@@ -0,0 +1,274 @@
+// Copyright 2017 Serde Developers
+//
+// Licensed under the Apache License, Version 2.0 <LICENSE-APACHE or
+// http://www.apache.org/licenses/LICENSE-2.0> or the MIT license
+// <LICENSE-MIT or http://opensource.org/licenses/MIT>, at your
+// option. This file may not be copied, modified, or distributed
+// except according to those terms.
+
+use std::fmt;
+use std::ops;
+
+use super::Value;
+use map::Map;
+
+/// A type that can be used to index into a `serde_json::Value`.
+///
+/// The [`get`] and [`get_mut`] methods of `Value` accept any type that
+/// implements `Index`, as does the [square-bracket indexing operator]. This
+/// trait is implemented for strings which are used as the index into a JSON
+/// map, and for `usize` which is used as the index into a JSON array.
+///
+/// [`get`]: ../enum.Value.html#method.get
+/// [`get_mut`]: ../enum.Value.html#method.get_mut
+/// [square-bracket indexing operator]: ../enum.Value.html#impl-Index%3CI%3E
+///
+/// This trait is sealed and cannot be implemented for types outside of
+/// `serde_json`.
+///
+/// # Examples
+///
+/// ```rust
+/// # #[macro_use]
+/// # extern crate serde_json;
+/// #
+/// # fn main() {
+/// let data = json!({ "inner": [1, 2, 3] });
+///
+/// // Data is a JSON map so it can be indexed with a string.
+/// let inner = &data["inner"];
+///
+/// // Inner is a JSON array so it can be indexed with an integer.
+/// let first = &inner[0];
+///
+/// assert_eq!(first, 1);
+/// # }
+/// ```
+pub trait Index: private::Sealed {
+ /// Return None if the key is not already in the array or object.
+ #[doc(hidden)]
+ fn index_into<'v>(&self, v: &'v Value) -> Option<&'v Value>;
+
+ /// Return None if the key is not already in the array or object.
+ #[doc(hidden)]
+ fn index_into_mut<'v>(&self, v: &'v mut Value) -> Option<&'v mut Value>;
+
+ /// Panic if array index out of bounds. If key is not already in the object,
+ /// insert it with a value of null. Panic if Value is a type that cannot be
+ /// indexed into, except if Value is null then it can be treated as an empty
+ /// object.
+ #[doc(hidden)]
+ fn index_or_insert<'v>(&self, v: &'v mut Value) -> &'v mut Value;
+}
+
+impl Index for usize {
+ fn index_into<'v>(&self, v: &'v Value) -> Option<&'v Value> {
+ match *v {
+ Value::Array(ref vec) => vec.get(*self),
+ _ => None,
+ }
+ }
+ fn index_into_mut<'v>(&self, v: &'v mut Value) -> Option<&'v mut Value> {
+ match *v {
+ Value::Array(ref mut vec) => vec.get_mut(*self),
+ _ => None,
+ }
+ }
+ fn index_or_insert<'v>(&self, v: &'v mut Value) -> &'v mut Value {
+ match *v {
+ Value::Array(ref mut vec) => {
+ let len = vec.len();
+ vec.get_mut(*self).unwrap_or_else(|| {
+ panic!(
+ "cannot access index {} of JSON array of length {}",
+ self, len
+ )
+ })
+ }
+ _ => panic!("cannot access index {} of JSON {}", self, Type(v)),
+ }
+ }
+}
+
+impl Index for str {
+ fn index_into<'v>(&self, v: &'v Value) -> Option<&'v Value> {
+ match *v {
+ Value::Object(ref map) => map.get(self),
+ _ => None,
+ }
+ }
+ fn index_into_mut<'v>(&self, v: &'v mut Value) -> Option<&'v mut Value> {
+ match *v {
+ Value::Object(ref mut map) => map.get_mut(self),
+ _ => None,
+ }
+ }
+ fn index_or_insert<'v>(&self, v: &'v mut Value) -> &'v mut Value {
+ if let Value::Null = *v {
+ *v = Value::Object(Map::new());
+ }
+ match *v {
+ Value::Object(ref mut map) => map.entry(self.to_owned()).or_insert(Value::Null),
+ _ => panic!("cannot access key {:?} in JSON {}", self, Type(v)),
+ }
+ }
+}
+
+impl Index for String {
+ fn index_into<'v>(&self, v: &'v Value) -> Option<&'v Value> {
+ self[..].index_into(v)
+ }
+ fn index_into_mut<'v>(&self, v: &'v mut Value) -> Option<&'v mut Value> {
+ self[..].index_into_mut(v)
+ }
+ fn index_or_insert<'v>(&self, v: &'v mut Value) -> &'v mut Value {
+ self[..].index_or_insert(v)
+ }
+}
+
+impl<'a, T: ?Sized> Index for &'a T
+where
+ T: Index,
+{
+ fn index_into<'v>(&self, v: &'v Value) -> Option<&'v Value> {
+ (**self).index_into(v)
+ }
+ fn index_into_mut<'v>(&self, v: &'v mut Value) -> Option<&'v mut Value> {
+ (**self).index_into_mut(v)
+ }
+ fn index_or_insert<'v>(&self, v: &'v mut Value) -> &'v mut Value {
+ (**self).index_or_insert(v)
+ }
+}
+
+// Prevent users from implementing the Index trait.
+mod private {
+ pub trait Sealed {}
+ impl Sealed for usize {}
+ impl Sealed for str {}
+ impl Sealed for String {}
+ impl<'a, T: ?Sized> Sealed for &'a T where T: Sealed {}
+}
+
+/// Used in panic messages.
+struct Type<'a>(&'a Value);
+
+impl<'a> fmt::Display for Type<'a> {
+ fn fmt(&self, formatter: &mut fmt::Formatter) -> fmt::Result {
+ match *self.0 {
+ Value::Null => formatter.write_str("null"),
+ Value::Bool(_) => formatter.write_str("boolean"),
+ Value::Number(_) => formatter.write_str("number"),
+ Value::String(_) => formatter.write_str("string"),
+ Value::Array(_) => formatter.write_str("array"),
+ Value::Object(_) => formatter.write_str("object"),
+ }
+ }
+}
+
+// The usual semantics of Index is to panic on invalid indexing.
+//
+// That said, the usual semantics are for things like Vec and BTreeMap which
+// have different use cases than Value. If you are working with a Vec, you know
+// that you are working with a Vec and you can get the len of the Vec and make
+// sure your indices are within bounds. The Value use cases are more
+// loosey-goosey. You got some JSON from an endpoint and you want to pull values
+// out of it. Outside of this Index impl, you already have the option of using
+// value.as_array() and working with the Vec directly, or matching on
+// Value::Array and getting the Vec directly. The Index impl means you can skip
+// that and index directly into the thing using a concise syntax. You don't have
+// to check the type, you don't have to check the len, it is all about what you
+// expect the Value to look like.
+//
+// Basically the use cases that would be well served by panicking here are
+// better served by using one of the other approaches: get and get_mut,
+// as_array, or match. The value of this impl is that it adds a way of working
+// with Value that is not well served by the existing approaches: concise and
+// careless and sometimes that is exactly what you want.
+impl<I> ops::Index<I> for Value
+where
+ I: Index,
+{
+ type Output = Value;
+
+ /// Index into a `serde_json::Value` using the syntax `value[0]` or
+ /// `value["k"]`.
+ ///
+ /// Returns `Value::Null` if the type of `self` does not match the type of
+ /// the index, for example if the index is a string and `self` is an array
+ /// or a number. Also returns `Value::Null` if the given key does not exist
+ /// in the map or the given index is not within the bounds of the array.
+ ///
+ /// For retrieving deeply nested values, you should have a look at the
+ /// `Value::pointer` method.
+ ///
+ /// # Examples
+ ///
+ /// ```rust
+ /// # #[macro_use]
+ /// # extern crate serde_json;
+ /// #
+ /// # fn main() {
+ /// let data = json!({
+ /// "x": {
+ /// "y": ["z", "zz"]
+ /// }
+ /// });
+ ///
+ /// assert_eq!(data["x"]["y"], json!(["z", "zz"]));
+ /// assert_eq!(data["x"]["y"][0], json!("z"));
+ ///
+ /// assert_eq!(data["a"], json!(null)); // returns null for undefined values
+ /// assert_eq!(data["a"]["b"], json!(null)); // does not panic
+ /// # }
+ /// ```
+ fn index(&self, index: I) -> &Value {
+ static NULL: Value = Value::Null;
+ index.index_into(self).unwrap_or(&NULL)
+ }
+}
+
+impl<I> ops::IndexMut<I> for Value
+where
+ I: Index,
+{
+ /// Write into a `serde_json::Value` using the syntax `value[0] = ...` or
+ /// `value["k"] = ...`.
+ ///
+ /// If the index is a number, the value must be an array of length bigger
+ /// than the index. Indexing into a value that is not an array or an array
+ /// that is too small will panic.
+ ///
+ /// If the index is a string, the value must be an object or null which is
+ /// treated like an empty object. If the key is not already present in the
+ /// object, it will be inserted with a value of null. Indexing into a value
+ /// that is neither an object nor null will panic.
+ ///
+ /// # Examples
+ ///
+ /// ```rust
+ /// # #[macro_use]
+ /// # extern crate serde_json;
+ /// #
+ /// # fn main() {
+ /// let mut data = json!({ "x": 0 });
+ ///
+ /// // replace an existing key
+ /// data["x"] = json!(1);
+ ///
+ /// // insert a new key
+ /// data["y"] = json!([false, false, false]);
+ ///
+ /// // replace an array value
+ /// data["y"][0] = json!(true);
+ ///
+ /// // inserted a deeply nested key
+ /// data["a"]["b"]["c"]["d"] = json!(true);
+ ///
+ /// println!("{}", data);
+ /// # }
+ /// ```
+ fn index_mut(&mut self, index: I) -> &mut Value {
+ index.index_or_insert(self)
+ }
+}
new file mode 100644
--- /dev/null
+++ b/third_party/rust/serde_json/src/value/mod.rs
@@ -0,0 +1,1126 @@
+// Copyright 2017 Serde Developers
+//
+// Licensed under the Apache License, Version 2.0 <LICENSE-APACHE or
+// http://www.apache.org/licenses/LICENSE-2.0> or the MIT license
+// <LICENSE-MIT or http://opensource.org/licenses/MIT>, at your
+// option. This file may not be copied, modified, or distributed
+// except according to those terms.
+
+//! The Value enum, a loosely typed way of representing any valid JSON value.
+//!
+//! # Constructing JSON
+//!
+//! Serde JSON provides a [`json!` macro][macro] to build `serde_json::Value`
+//! objects with very natural JSON syntax. In order to use this macro,
+//! `serde_json` needs to be imported with the `#[macro_use]` attribute.
+//!
+//! ```rust
+//! #[macro_use]
+//! extern crate serde_json;
+//!
+//! fn main() {
+//! // The type of `john` is `serde_json::Value`
+//! let john = json!({
+//! "name": "John Doe",
+//! "age": 43,
+//! "phones": [
+//! "+44 1234567",
+//! "+44 2345678"
+//! ]
+//! });
+//!
+//! println!("first phone number: {}", john["phones"][0]);
+//!
+//! // Convert to a string of JSON and print it out
+//! println!("{}", john.to_string());
+//! }
+//! ```
+//!
+//! The `Value::to_string()` function converts a `serde_json::Value` into a
+//! `String` of JSON text.
+//!
+//! One neat thing about the `json!` macro is that variables and expressions can
+//! be interpolated directly into the JSON value as you are building it. Serde
+//! will check at compile time that the value you are interpolating is able to
+//! be represented as JSON.
+//!
+//! ```rust
+//! # #[macro_use]
+//! # extern crate serde_json;
+//! #
+//! # fn random_phone() -> u16 { 0 }
+//! #
+//! # fn main() {
+//! let full_name = "John Doe";
+//! let age_last_year = 42;
+//!
+//! // The type of `john` is `serde_json::Value`
+//! let john = json!({
+//! "name": full_name,
+//! "age": age_last_year + 1,
+//! "phones": [
+//! format!("+44 {}", random_phone())
+//! ]
+//! });
+//! # let _ = john;
+//! # }
+//! ```
+//!
+//! A string of JSON data can be parsed into a `serde_json::Value` by the
+//! [`serde_json::from_str`][from_str] function. There is also
+//! [`from_slice`][from_slice] for parsing from a byte slice &[u8] and
+//! [`from_reader`][from_reader] for parsing from any `io::Read` like a File or
+//! a TCP stream.
+//!
+//! ```rust
+//! extern crate serde_json;
+//!
+//! use serde_json::{Value, Error};
+//!
+//! fn untyped_example() -> Result<(), Error> {
+//! // Some JSON input data as a &str. Maybe this comes from the user.
+//! let data = r#"{
+//! "name": "John Doe",
+//! "age": 43,
+//! "phones": [
+//! "+44 1234567",
+//! "+44 2345678"
+//! ]
+//! }"#;
+//!
+//! // Parse the string of data into serde_json::Value.
+//! let v: Value = serde_json::from_str(data)?;
+//!
+//! // Access parts of the data by indexing with square brackets.
+//! println!("Please call {} at the number {}", v["name"], v["phones"][0]);
+//!
+//! Ok(())
+//! }
+//! #
+//! # fn main() {
+//! # untyped_example().unwrap();
+//! # }
+//! ```
+//!
+//! [macro]: https://docs.serde.rs/serde_json/macro.json.html
+//! [from_str]: https://docs.serde.rs/serde_json/de/fn.from_str.html
+//! [from_slice]: https://docs.serde.rs/serde_json/de/fn.from_slice.html
+//! [from_reader]: https://docs.serde.rs/serde_json/de/fn.from_reader.html
+
+use std::fmt::{self, Debug};
+use std::io;
+use std::mem;
+use std::str;
+
+use serde::de::DeserializeOwned;
+use serde::ser::Serialize;
+
+use error::Error;
+pub use map::Map;
+pub use number::Number;
+
+pub use self::index::Index;
+
+use self::ser::Serializer;
+
+/// Represents any valid JSON value.
+///
+/// See the `serde_json::value` module documentation for usage examples.
+#[derive(Clone, PartialEq)]
+pub enum Value {
+ /// Represents a JSON null value.
+ ///
+ /// ```rust
+ /// # #[macro_use]
+ /// # extern crate serde_json;
+ /// #
+ /// # fn main() {
+ /// let v = json!(null);
+ /// # }
+ /// ```
+ Null,
+
+ /// Represents a JSON boolean.
+ ///
+ /// ```rust
+ /// # #[macro_use]
+ /// # extern crate serde_json;
+ /// #
+ /// # fn main() {
+ /// let v = json!(true);
+ /// # }
+ /// ```
+ Bool(bool),
+
+ /// Represents a JSON number, whether integer or floating point.
+ ///
+ /// ```rust
+ /// # #[macro_use]
+ /// # extern crate serde_json;
+ /// #
+ /// # fn main() {
+ /// let v = json!(12.5);
+ /// # }
+ /// ```
+ Number(Number),
+
+ /// Represents a JSON string.
+ ///
+ /// ```rust
+ /// # #[macro_use]
+ /// # extern crate serde_json;
+ /// #
+ /// # fn main() {
+ /// let v = json!("a string");
+ /// # }
+ /// ```
+ String(String),
+
+ /// Represents a JSON array.
+ ///
+ /// ```rust
+ /// # #[macro_use]
+ /// # extern crate serde_json;
+ /// #
+ /// # fn main() {
+ /// let v = json!(["an", "array"]);
+ /// # }
+ /// ```
+ Array(Vec<Value>),
+
+ /// Represents a JSON object.
+ ///
+ /// By default the map is backed by a BTreeMap. Enable the `preserve_order`
+ /// feature of serde_json to use IndexMap instead, which preserves
+ /// entries in the order they are inserted into the map. In particular, this
+ /// allows JSON data to be deserialized into a Value and serialized to a
+ /// string while retaining the order of map keys in the input.
+ ///
+ /// ```rust
+ /// # #[macro_use]
+ /// # extern crate serde_json;
+ /// #
+ /// # fn main() {
+ /// let v = json!({ "an": "object" });
+ /// # }
+ /// ```
+ Object(Map<String, Value>),
+}
+
+impl Debug for Value {
+ fn fmt(&self, formatter: &mut fmt::Formatter) -> fmt::Result {
+ match *self {
+ Value::Null => formatter.debug_tuple("Null").finish(),
+ Value::Bool(v) => formatter.debug_tuple("Bool").field(&v).finish(),
+ Value::Number(ref v) => Debug::fmt(v, formatter),
+ Value::String(ref v) => formatter.debug_tuple("String").field(v).finish(),
+ Value::Array(ref v) => formatter.debug_tuple("Array").field(v).finish(),
+ Value::Object(ref v) => formatter.debug_tuple("Object").field(v).finish(),
+ }
+ }
+}
+
+struct WriterFormatter<'a, 'b: 'a> {
+ inner: &'a mut fmt::Formatter<'b>,
+}
+
+impl<'a, 'b> io::Write for WriterFormatter<'a, 'b> {
+ fn write(&mut self, buf: &[u8]) -> io::Result<usize> {
+ fn io_error<E>(_: E) -> io::Error {
+ // Error value does not matter because fmt::Display impl below just
+ // maps it to fmt::Error
+ io::Error::new(io::ErrorKind::Other, "fmt error")
+ }
+ let s = try!(str::from_utf8(buf).map_err(io_error));
+ try!(self.inner.write_str(s).map_err(io_error));
+ Ok(buf.len())
+ }
+
+ fn flush(&mut self) -> io::Result<()> {
+ Ok(())
+ }
+}
+
+impl fmt::Display for Value {
+ /// Display a JSON value as a string.
+ ///
+ /// ```rust
+ /// # #[macro_use]
+ /// # extern crate serde_json;
+ /// #
+ /// # fn main() {
+ /// let json = json!({ "city": "London", "street": "10 Downing Street" });
+ ///
+ /// // Compact format:
+ /// //
+ /// // {"city":"London","street":"10 Downing Street"}
+ /// let compact = format!("{}", json);
+ /// assert_eq!(compact,
+ /// "{\"city\":\"London\",\"street\":\"10 Downing Street\"}");
+ ///
+ /// // Pretty format:
+ /// //
+ /// // {
+ /// // "city": "London",
+ /// // "street": "10 Downing Street"
+ /// // }
+ /// let pretty = format!("{:#}", json);
+ /// assert_eq!(pretty,
+ /// "{\n \"city\": \"London\",\n \"street\": \"10 Downing Street\"\n}");
+ /// # }
+ /// ```
+ fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
+ let alternate = f.alternate();
+ let mut wr = WriterFormatter { inner: f };
+ if alternate {
+ // {:#}
+ super::ser::to_writer_pretty(&mut wr, self).map_err(|_| fmt::Error)
+ } else {
+ // {}
+ super::ser::to_writer(&mut wr, self).map_err(|_| fmt::Error)
+ }
+ }
+}
+
+fn parse_index(s: &str) -> Option<usize> {
+ if s.starts_with('+') || (s.starts_with('0') && s.len() != 1) {
+ return None;
+ }
+ s.parse().ok()
+}
+
+impl Value {
+ /// Index into a JSON array or map. A string index can be used to access a
+ /// value in a map, and a usize index can be used to access an element of an
+ /// array.
+ ///
+ /// Returns `None` if the type of `self` does not match the type of the
+ /// index, for example if the index is a string and `self` is an array or a
+ /// number. Also returns `None` if the given key does not exist in the map
+ /// or the given index is not within the bounds of the array.
+ ///
+ /// ```rust
+ /// # #[macro_use]
+ /// # extern crate serde_json;
+ /// #
+ /// # fn main() {
+ /// let object = json!({ "A": 65, "B": 66, "C": 67 });
+ /// assert_eq!(*object.get("A").unwrap(), json!(65));
+ ///
+ /// let array = json!([ "A", "B", "C" ]);
+ /// assert_eq!(*array.get(2).unwrap(), json!("C"));
+ ///
+ /// assert_eq!(array.get("A"), None);
+ /// # }
+ /// ```
+ ///
+ /// Square brackets can also be used to index into a value in a more concise
+ /// way. This returns `Value::Null` in cases where `get` would have returned
+ /// `None`.
+ ///
+ /// ```rust
+ /// # #[macro_use]
+ /// # extern crate serde_json;
+ /// #
+ /// # fn main() {
+ /// let object = json!({
+ /// "A": ["a", "á", "à"],
+ /// "B": ["b", "b́"],
+ /// "C": ["c", "ć", "ć̣", "ḉ"],
+ /// });
+ /// assert_eq!(object["B"][0], json!("b"));
+ ///
+ /// assert_eq!(object["D"], json!(null));
+ /// assert_eq!(object[0]["x"]["y"]["z"], json!(null));
+ /// # }
+ /// ```
+ pub fn get<I: Index>(&self, index: I) -> Option<&Value> {
+ index.index_into(self)
+ }
+
+ /// Mutably index into a JSON array or map. A string index can be used to
+ /// access a value in a map, and a usize index can be used to access an
+ /// element of an array.
+ ///
+ /// Returns `None` if the type of `self` does not match the type of the
+ /// index, for example if the index is a string and `self` is an array or a
+ /// number. Also returns `None` if the given key does not exist in the map
+ /// or the given index is not within the bounds of the array.
+ ///
+ /// ```rust
+ /// # #[macro_use]
+ /// # extern crate serde_json;
+ /// #
+ /// # fn main() {
+ /// let mut object = json!({ "A": 65, "B": 66, "C": 67 });
+ /// *object.get_mut("A").unwrap() = json!(69);
+ ///
+ /// let mut array = json!([ "A", "B", "C" ]);
+ /// *array.get_mut(2).unwrap() = json!("D");
+ /// # }
+ /// ```
+ pub fn get_mut<I: Index>(&mut self, index: I) -> Option<&mut Value> {
+ index.index_into_mut(self)
+ }
+
+ /// Returns true if the `Value` is an Object. Returns false otherwise.
+ ///
+ /// For any Value on which `is_object` returns true, `as_object` and
+ /// `as_object_mut` are guaranteed to return the map representation of the
+ /// object.
+ ///
+ /// ```rust
+ /// # #[macro_use]
+ /// # extern crate serde_json;
+ /// #
+ /// # fn main() {
+ /// let obj = json!({ "a": { "nested": true }, "b": ["an", "array"] });
+ ///
+ /// assert!(obj.is_object());
+ /// assert!(obj["a"].is_object());
+ ///
+ /// // array, not an object
+ /// assert!(!obj["b"].is_object());
+ /// # }
+ /// ```
+ pub fn is_object(&self) -> bool {
+ self.as_object().is_some()
+ }
+
+ /// If the `Value` is an Object, returns the associated Map. Returns None
+ /// otherwise.
+ ///
+ /// ```rust
+ /// # #[macro_use]
+ /// # extern crate serde_json;
+ /// #
+ /// # fn main() {
+ /// let v = json!({ "a": { "nested": true }, "b": ["an", "array"] });
+ ///
+ /// // The length of `{"nested": true}` is 1 entry.
+ /// assert_eq!(v["a"].as_object().unwrap().len(), 1);
+ ///
+ /// // The array `["an", "array"]` is not an object.
+ /// assert_eq!(v["b"].as_object(), None);
+ /// # }
+ /// ```
+ pub fn as_object(&self) -> Option<&Map<String, Value>> {
+ match *self {
+ Value::Object(ref map) => Some(map),
+ _ => None,
+ }
+ }
+
+ /// If the `Value` is an Object, returns the associated mutable Map.
+ /// Returns None otherwise.
+ ///
+ /// ```rust
+ /// # #[macro_use]
+ /// # extern crate serde_json;
+ /// #
+ /// # fn main() {
+ /// let mut v = json!({ "a": { "nested": true } });
+ ///
+ /// v["a"].as_object_mut().unwrap().clear();
+ /// assert_eq!(v, json!({ "a": {} }));
+ /// # }
+ ///
+ /// ```
+ pub fn as_object_mut(&mut self) -> Option<&mut Map<String, Value>> {
+ match *self {
+ Value::Object(ref mut map) => Some(map),
+ _ => None,
+ }
+ }
+
+ /// Returns true if the `Value` is an Array. Returns false otherwise.
+ ///
+ /// For any Value on which `is_array` returns true, `as_array` and
+ /// `as_array_mut` are guaranteed to return the vector representing the
+ /// array.
+ ///
+ /// ```rust
+ /// # #[macro_use]
+ /// # extern crate serde_json;
+ /// #
+ /// # fn main() {
+ /// let obj = json!({ "a": ["an", "array"], "b": { "an": "object" } });
+ ///
+ /// assert!(obj["a"].is_array());
+ ///
+ /// // an object, not an array
+ /// assert!(!obj["b"].is_array());
+ /// # }
+ /// ```
+ pub fn is_array(&self) -> bool {
+ self.as_array().is_some()
+ }
+
+ /// If the `Value` is an Array, returns the associated vector. Returns None
+ /// otherwise.
+ ///
+ /// ```rust
+ /// # #[macro_use]
+ /// # extern crate serde_json;
+ /// #
+ /// # fn main() {
+ /// let v = json!({ "a": ["an", "array"], "b": { "an": "object" } });
+ ///
+ /// // The length of `["an", "array"]` is 2 elements.
+ /// assert_eq!(v["a"].as_array().unwrap().len(), 2);
+ ///
+ /// // The object `{"an": "object"}` is not an array.
+ /// assert_eq!(v["b"].as_array(), None);
+ /// # }
+ /// ```
+ pub fn as_array(&self) -> Option<&Vec<Value>> {
+ match *self {
+ Value::Array(ref array) => Some(&*array),
+ _ => None,
+ }
+ }
+
+ /// If the `Value` is an Array, returns the associated mutable vector.
+ /// Returns None otherwise.
+ ///
+ /// ```rust
+ /// # #[macro_use]
+ /// # extern crate serde_json;
+ /// #
+ /// # fn main() {
+ /// let mut v = json!({ "a": ["an", "array"] });
+ ///
+ /// v["a"].as_array_mut().unwrap().clear();
+ /// assert_eq!(v, json!({ "a": [] }));
+ /// # }
+ /// ```
+ pub fn as_array_mut(&mut self) -> Option<&mut Vec<Value>> {
+ match *self {
+ Value::Array(ref mut list) => Some(list),
+ _ => None,
+ }
+ }
+
+ /// Returns true if the `Value` is a String. Returns false otherwise.
+ ///
+ /// For any Value on which `is_string` returns true, `as_str` is guaranteed
+ /// to return the string slice.
+ ///
+ /// ```rust
+ /// # #[macro_use]
+ /// # extern crate serde_json;
+ /// #
+ /// # fn main() {
+ /// let v = json!({ "a": "some string", "b": false });
+ ///
+ /// assert!(v["a"].is_string());
+ ///
+ /// // The boolean `false` is not a string.
+ /// assert!(!v["b"].is_string());
+ /// # }
+ /// ```
+ pub fn is_string(&self) -> bool {
+ self.as_str().is_some()
+ }
+
+ /// If the `Value` is a String, returns the associated str. Returns None
+ /// otherwise.
+ ///
+ /// ```rust
+ /// # #[macro_use]
+ /// # extern crate serde_json;
+ /// #
+ /// # fn main() {
+ /// let v = json!({ "a": "some string", "b": false });
+ ///
+ /// assert_eq!(v["a"].as_str(), Some("some string"));
+ ///
+ /// // The boolean `false` is not a string.
+ /// assert_eq!(v["b"].as_str(), None);
+ ///
+ /// // JSON values are printed in JSON representation, so strings are in quotes.
+ /// //
+ /// // The value is: "some string"
+ /// println!("The value is: {}", v["a"]);
+ ///
+ /// // Rust strings are printed without quotes.
+ /// //
+ /// // The value is: some string
+ /// println!("The value is: {}", v["a"].as_str().unwrap());
+ /// # }
+ /// ```
+ pub fn as_str(&self) -> Option<&str> {
+ match *self {
+ Value::String(ref s) => Some(s),
+ _ => None,
+ }
+ }
+
+ /// Returns true if the `Value` is a Number. Returns false otherwise.
+ ///
+ /// ```rust
+ /// # #[macro_use]
+ /// # extern crate serde_json;
+ /// #
+ /// # fn main() {
+ /// let v = json!({ "a": 1, "b": "2" });
+ ///
+ /// assert!(v["a"].is_number());
+ ///
+ /// // The string `"2"` is a string, not a number.
+ /// assert!(!v["b"].is_number());
+ /// # }
+ /// ```
+ pub fn is_number(&self) -> bool {
+ match *self {
+ Value::Number(_) => true,
+ _ => false,
+ }
+ }
+
+ /// Returns true if the `Value` is an integer between `i64::MIN` and
+ /// `i64::MAX`.
+ ///
+ /// For any Value on which `is_i64` returns true, `as_i64` is guaranteed to
+ /// return the integer value.
+ ///
+ /// ```rust
+ /// # #[macro_use]
+ /// # extern crate serde_json;
+ /// #
+ /// # fn main() {
+ /// let big = i64::max_value() as u64 + 10;
+ /// let v = json!({ "a": 64, "b": big, "c": 256.0 });
+ ///
+ /// assert!(v["a"].is_i64());
+ ///
+ /// // Greater than i64::MAX.
+ /// assert!(!v["b"].is_i64());
+ ///
+ /// // Numbers with a decimal point are not considered integers.
+ /// assert!(!v["c"].is_i64());
+ /// # }
+ /// ```
+ pub fn is_i64(&self) -> bool {
+ match *self {
+ Value::Number(ref n) => n.is_i64(),
+ _ => false,
+ }
+ }
+
+ /// Returns true if the `Value` is an integer between zero and `u64::MAX`.
+ ///
+ /// For any Value on which `is_u64` returns true, `as_u64` is guaranteed to
+ /// return the integer value.
+ ///
+ /// ```rust
+ /// # #[macro_use]
+ /// # extern crate serde_json;
+ /// #
+ /// # fn main() {
+ /// let v = json!({ "a": 64, "b": -64, "c": 256.0 });
+ ///
+ /// assert!(v["a"].is_u64());
+ ///
+ /// // Negative integer.
+ /// assert!(!v["b"].is_u64());
+ ///
+ /// // Numbers with a decimal point are not considered integers.
+ /// assert!(!v["c"].is_u64());
+ /// # }
+ /// ```
+ pub fn is_u64(&self) -> bool {
+ match *self {
+ Value::Number(ref n) => n.is_u64(),
+ _ => false,
+ }
+ }
+
+ /// Returns true if the `Value` is a number that can be represented by f64.
+ ///
+ /// For any Value on which `is_f64` returns true, `as_f64` is guaranteed to
+ /// return the floating point value.
+ ///
+ /// Currently this function returns true if and only if both `is_i64` and
+ /// `is_u64` return false but this is not a guarantee in the future.
+ ///
+ /// ```rust
+ /// # #[macro_use]
+ /// # extern crate serde_json;
+ /// #
+ /// # fn main() {
+ /// let v = json!({ "a": 256.0, "b": 64, "c": -64 });
+ ///
+ /// assert!(v["a"].is_f64());
+ ///
+ /// // Integers.
+ /// assert!(!v["b"].is_f64());
+ /// assert!(!v["c"].is_f64());
+ /// # }
+ /// ```
+ pub fn is_f64(&self) -> bool {
+ match *self {
+ Value::Number(ref n) => n.is_f64(),
+ _ => false,
+ }
+ }
+
+ /// If the `Value` is an integer, represent it as i64 if possible. Returns
+ /// None otherwise.
+ ///
+ /// ```rust
+ /// # #[macro_use]
+ /// # extern crate serde_json;
+ /// #
+ /// # fn main() {
+ /// let big = i64::max_value() as u64 + 10;
+ /// let v = json!({ "a": 64, "b": big, "c": 256.0 });
+ ///
+ /// assert_eq!(v["a"].as_i64(), Some(64));
+ /// assert_eq!(v["b"].as_i64(), None);
+ /// assert_eq!(v["c"].as_i64(), None);
+ /// # }
+ /// ```
+ pub fn as_i64(&self) -> Option<i64> {
+ match *self {
+ Value::Number(ref n) => n.as_i64(),
+ _ => None,
+ }
+ }
+
+ /// If the `Value` is an integer, represent it as u64 if possible. Returns
+ /// None otherwise.
+ ///
+ /// ```rust
+ /// # #[macro_use]
+ /// # extern crate serde_json;
+ /// #
+ /// # fn main() {
+ /// let v = json!({ "a": 64, "b": -64, "c": 256.0 });
+ ///
+ /// assert_eq!(v["a"].as_u64(), Some(64));
+ /// assert_eq!(v["b"].as_u64(), None);
+ /// assert_eq!(v["c"].as_u64(), None);
+ /// # }
+ /// ```
+ pub fn as_u64(&self) -> Option<u64> {
+ match *self {
+ Value::Number(ref n) => n.as_u64(),
+ _ => None,
+ }
+ }
+
+ /// If the `Value` is a number, represent it as f64 if possible. Returns
+ /// None otherwise.
+ ///
+ /// ```rust
+ /// # #[macro_use]
+ /// # extern crate serde_json;
+ /// #
+ /// # fn main() {
+ /// let v = json!({ "a": 256.0, "b": 64, "c": -64 });
+ ///
+ /// assert_eq!(v["a"].as_f64(), Some(256.0));
+ /// assert_eq!(v["b"].as_f64(), Some(64.0));
+ /// assert_eq!(v["c"].as_f64(), Some(-64.0));
+ /// # }
+ /// ```
+ pub fn as_f64(&self) -> Option<f64> {
+ match *self {
+ Value::Number(ref n) => n.as_f64(),
+ _ => None,
+ }
+ }
+
+ /// Returns true if the `Value` is a Boolean. Returns false otherwise.
+ ///
+ /// For any Value on which `is_boolean` returns true, `as_bool` is
+ /// guaranteed to return the boolean value.
+ ///
+ /// ```rust
+ /// # #[macro_use]
+ /// # extern crate serde_json;
+ /// #
+ /// # fn main() {
+ /// let v = json!({ "a": false, "b": "false" });
+ ///
+ /// assert!(v["a"].is_boolean());
+ ///
+ /// // The string `"false"` is a string, not a boolean.
+ /// assert!(!v["b"].is_boolean());
+ /// # }
+ /// ```
+ pub fn is_boolean(&self) -> bool {
+ self.as_bool().is_some()
+ }
+
+ /// If the `Value` is a Boolean, returns the associated bool. Returns None
+ /// otherwise.
+ ///
+ /// ```rust
+ /// # #[macro_use]
+ /// # extern crate serde_json;
+ /// #
+ /// # fn main() {
+ /// let v = json!({ "a": false, "b": "false" });
+ ///
+ /// assert_eq!(v["a"].as_bool(), Some(false));
+ ///
+ /// // The string `"false"` is a string, not a boolean.
+ /// assert_eq!(v["b"].as_bool(), None);
+ /// # }
+ /// ```
+ pub fn as_bool(&self) -> Option<bool> {
+ match *self {
+ Value::Bool(b) => Some(b),
+ _ => None,
+ }
+ }
+
+ /// Returns true if the `Value` is a Null. Returns false otherwise.
+ ///
+ /// For any Value on which `is_null` returns true, `as_null` is guaranteed
+ /// to return `Some(())`.
+ ///
+ /// ```rust
+ /// # #[macro_use]
+ /// # extern crate serde_json;
+ /// #
+ /// # fn main() {
+ /// let v = json!({ "a": null, "b": false });
+ ///
+ /// assert!(v["a"].is_null());
+ ///
+ /// // The boolean `false` is not null.
+ /// assert!(!v["b"].is_null());
+ /// # }
+ /// ```
+ pub fn is_null(&self) -> bool {
+ self.as_null().is_some()
+ }
+
+ /// If the `Value` is a Null, returns (). Returns None otherwise.
+ ///
+ /// ```rust
+ /// # #[macro_use]
+ /// # extern crate serde_json;
+ /// #
+ /// # fn main() {
+ /// let v = json!({ "a": null, "b": false });
+ ///
+ /// assert_eq!(v["a"].as_null(), Some(()));
+ ///
+ /// // The boolean `false` is not null.
+ /// assert_eq!(v["b"].as_null(), None);
+ /// # }
+ /// ```
+ pub fn as_null(&self) -> Option<()> {
+ match *self {
+ Value::Null => Some(()),
+ _ => None,
+ }
+ }
+
+ /// Looks up a value by a JSON Pointer.
+ ///
+ /// JSON Pointer defines a string syntax for identifying a specific value
+ /// within a JavaScript Object Notation (JSON) document.
+ ///
+ /// A Pointer is a Unicode string with the reference tokens separated by `/`.
+ /// Inside tokens `/` is replaced by `~1` and `~` is replaced by `~0`. The
+ /// addressed value is returned and if there is no such value `None` is
+ /// returned.
+ ///
+ /// For more information read [RFC6901](https://tools.ietf.org/html/rfc6901).
+ ///
+ /// # Examples
+ ///
+ /// ```rust
+ /// # #[macro_use]
+ /// # extern crate serde_json;
+ /// #
+ /// # fn main() {
+ /// let data = json!({
+ /// "x": {
+ /// "y": ["z", "zz"]
+ /// }
+ /// });
+ ///
+ /// assert_eq!(data.pointer("/x/y/1").unwrap(), &json!("zz"));
+ /// assert_eq!(data.pointer("/a/b/c"), None);
+ /// # }
+ /// ```
+ pub fn pointer<'a>(&'a self, pointer: &str) -> Option<&'a Value> {
+ if pointer == "" {
+ return Some(self);
+ }
+ if !pointer.starts_with('/') {
+ return None;
+ }
+ let tokens = pointer
+ .split('/')
+ .skip(1)
+ .map(|x| x.replace("~1", "/").replace("~0", "~"));
+ let mut target = self;
+
+ for token in tokens {
+ let target_opt = match *target {
+ Value::Object(ref map) => map.get(&token),
+ Value::Array(ref list) => parse_index(&token).and_then(|x| list.get(x)),
+ _ => return None,
+ };
+ if let Some(t) = target_opt {
+ target = t;
+ } else {
+ return None;
+ }
+ }
+ Some(target)
+ }
+
+ /// Looks up a value by a JSON Pointer and returns a mutable reference to
+ /// that value.
+ ///
+ /// JSON Pointer defines a string syntax for identifying a specific value
+ /// within a JavaScript Object Notation (JSON) document.
+ ///
+ /// A Pointer is a Unicode string with the reference tokens separated by `/`.
+ /// Inside tokens `/` is replaced by `~1` and `~` is replaced by `~0`. The
+ /// addressed value is returned and if there is no such value `None` is
+ /// returned.
+ ///
+ /// For more information read [RFC6901](https://tools.ietf.org/html/rfc6901).
+ ///
+ /// # Example of Use
+ ///
+ /// ```rust
+ /// extern crate serde_json;
+ ///
+ /// use serde_json::Value;
+ ///
+ /// fn main() {
+ /// let s = r#"{"x": 1.0, "y": 2.0}"#;
+ /// let mut value: Value = serde_json::from_str(s).unwrap();
+ ///
+ /// // Check value using read-only pointer
+ /// assert_eq!(value.pointer("/x"), Some(&1.0.into()));
+ /// // Change value with direct assignment
+ /// *value.pointer_mut("/x").unwrap() = 1.5.into();
+ /// // Check that new value was written
+ /// assert_eq!(value.pointer("/x"), Some(&1.5.into()));
+ ///
+ /// // "Steal" ownership of a value. Can replace with any valid Value.
+ /// let old_x = value.pointer_mut("/x").map(Value::take).unwrap();
+ /// assert_eq!(old_x, 1.5);
+ /// assert_eq!(value.pointer("/x").unwrap(), &Value::Null);
+ /// }
+ /// ```
+ pub fn pointer_mut<'a>(&'a mut self, pointer: &str) -> Option<&'a mut Value> {
+ if pointer == "" {
+ return Some(self);
+ }
+ if !pointer.starts_with('/') {
+ return None;
+ }
+ let tokens = pointer
+ .split('/')
+ .skip(1)
+ .map(|x| x.replace("~1", "/").replace("~0", "~"));
+ let mut target = self;
+
+ for token in tokens {
+ // borrow checker gets confused about `target` being mutably borrowed too many times because of the loop
+ // this once-per-loop binding makes the scope clearer and circumvents the error
+ let target_once = target;
+ let target_opt = match *target_once {
+ Value::Object(ref mut map) => map.get_mut(&token),
+ Value::Array(ref mut list) => {
+ parse_index(&token).and_then(move |x| list.get_mut(x))
+ }
+ _ => return None,
+ };
+ if let Some(t) = target_opt {
+ target = t;
+ } else {
+ return None;
+ }
+ }
+ Some(target)
+ }
+
+ /// Takes the value out of the `Value`, leaving a `Null` in its place.
+ ///
+ /// ```rust
+ /// # #[macro_use]
+ /// # extern crate serde_json;
+ /// #
+ /// # fn main() {
+ /// let mut v = json!({ "x": "y" });
+ /// assert_eq!(v["x"].take(), json!("y"));
+ /// assert_eq!(v, json!({ "x": null }));
+ /// # }
+ /// ```
+ pub fn take(&mut self) -> Value {
+ mem::replace(self, Value::Null)
+ }
+}
+
+/// The default value is `Value::Null`.
+///
+/// This is useful for handling omitted `Value` fields when deserializing.
+///
+/// # Examples
+///
+/// ```rust
+/// # #[macro_use]
+/// # extern crate serde_derive;
+/// #
+/// # extern crate serde_json;
+/// #
+/// use serde_json::Value;
+///
+/// #[derive(Deserialize)]
+/// struct Settings {
+/// level: i32,
+/// #[serde(default)]
+/// extras: Value,
+/// }
+///
+/// # fn try_main() -> Result<(), serde_json::Error> {
+/// let data = r#" { "level": 42 } "#;
+/// let s: Settings = serde_json::from_str(data)?;
+///
+/// assert_eq!(s.level, 42);
+/// assert_eq!(s.extras, Value::Null);
+/// #
+/// # Ok(())
+/// # }
+/// #
+/// # fn main() {
+/// # try_main().unwrap()
+/// # }
+/// ```
+impl Default for Value {
+ fn default() -> Value {
+ Value::Null
+ }
+}
+
+mod de;
+mod from;
+mod index;
+mod partial_eq;
+mod ser;
+
+/// Convert a `T` into `serde_json::Value` which is an enum that can represent
+/// any valid JSON data.
+///
+/// ```rust
+/// extern crate serde;
+///
+/// #[macro_use]
+/// extern crate serde_derive;
+///
+/// #[macro_use]
+/// extern crate serde_json;
+///
+/// use std::error::Error;
+///
+/// #[derive(Serialize)]
+/// struct User {
+/// fingerprint: String,
+/// location: String,
+/// }
+///
+/// fn compare_json_values() -> Result<(), Box<Error>> {
+/// let u = User {
+/// fingerprint: "0xF9BA143B95FF6D82".to_owned(),
+/// location: "Menlo Park, CA".to_owned(),
+/// };
+///
+/// // The type of `expected` is `serde_json::Value`
+/// let expected = json!({
+/// "fingerprint": "0xF9BA143B95FF6D82",
+/// "location": "Menlo Park, CA",
+/// });
+///
+/// let v = serde_json::to_value(u).unwrap();
+/// assert_eq!(v, expected);
+///
+/// Ok(())
+/// }
+/// #
+/// # fn main() {
+/// # compare_json_values().unwrap();
+/// # }
+/// ```
+///
+/// # Errors
+///
+/// This conversion can fail if `T`'s implementation of `Serialize` decides to
+/// fail, or if `T` contains a map with non-string keys.
+///
+/// ```rust
+/// extern crate serde_json;
+///
+/// use std::collections::BTreeMap;
+///
+/// fn main() {
+/// // The keys in this map are vectors, not strings.
+/// let mut map = BTreeMap::new();
+/// map.insert(vec![32, 64], "x86");
+///
+/// println!("{}", serde_json::to_value(map).unwrap_err());
+/// }
+/// ```
+// Taking by value is more friendly to iterator adapters, option and result
+// consumers, etc. See https://github.com/serde-rs/json/pull/149.
+pub fn to_value<T>(value: T) -> Result<Value, Error>
+where
+ T: Serialize,
+{
+ value.serialize(Serializer)
+}
+
+/// Interpret a `serde_json::Value` as an instance of type `T`.
+///
+/// This conversion can fail if the structure of the Value does not match the
+/// structure expected by `T`, for example if `T` is a struct type but the Value
+/// contains something other than a JSON map. It can also fail if the structure
+/// is correct but `T`'s implementation of `Deserialize` decides that something
+/// is wrong with the data, for example required struct fields are missing from
+/// the JSON map or some number is too big to fit in the expected primitive
+/// type.
+///
+/// ```rust
+/// #[macro_use]
+/// extern crate serde_json;
+///
+/// #[macro_use]
+/// extern crate serde_derive;
+///
+/// extern crate serde;
+///
+/// #[derive(Deserialize, Debug)]
+/// struct User {
+/// fingerprint: String,
+/// location: String,
+/// }
+///
+/// fn main() {
+/// // The type of `j` is `serde_json::Value`
+/// let j = json!({
+/// "fingerprint": "0xF9BA143B95FF6D82",
+/// "location": "Menlo Park, CA"
+/// });
+///
+/// let u: User = serde_json::from_value(j).unwrap();
+/// println!("{:#?}", u);
+/// }
+/// ```
+pub fn from_value<T>(value: Value) -> Result<T, Error>
+where
+ T: DeserializeOwned,
+{
+ T::deserialize(value)
+}
new file mode 100644
--- /dev/null
+++ b/third_party/rust/serde_json/src/value/partial_eq.rs
@@ -0,0 +1,102 @@
+// Copyright 2017 Serde Developers
+//
+// Licensed under the Apache License, Version 2.0 <LICENSE-APACHE or
+// http://www.apache.org/licenses/LICENSE-2.0> or the MIT license
+// <LICENSE-MIT or http://opensource.org/licenses/MIT>, at your
+// option. This file may not be copied, modified, or distributed
+// except according to those terms.
+
+use super::Value;
+
+fn eq_i64(value: &Value, other: i64) -> bool {
+ value.as_i64().map_or(false, |i| i == other)
+}
+
+fn eq_u64(value: &Value, other: u64) -> bool {
+ value.as_u64().map_or(false, |i| i == other)
+}
+
+fn eq_f64(value: &Value, other: f64) -> bool {
+ value.as_f64().map_or(false, |i| i == other)
+}
+
+fn eq_bool(value: &Value, other: bool) -> bool {
+ value.as_bool().map_or(false, |i| i == other)
+}
+
+fn eq_str(value: &Value, other: &str) -> bool {
+ value.as_str().map_or(false, |i| i == other)
+}
+
+impl PartialEq<str> for Value {
+ fn eq(&self, other: &str) -> bool {
+ eq_str(self, other)
+ }
+}
+
+impl<'a> PartialEq<&'a str> for Value {
+ fn eq(&self, other: &&str) -> bool {
+ eq_str(self, *other)
+ }
+}
+
+impl PartialEq<Value> for str {
+ fn eq(&self, other: &Value) -> bool {
+ eq_str(other, self)
+ }
+}
+
+impl<'a> PartialEq<Value> for &'a str {
+ fn eq(&self, other: &Value) -> bool {
+ eq_str(other, *self)
+ }
+}
+
+impl PartialEq<String> for Value {
+ fn eq(&self, other: &String) -> bool {
+ eq_str(self, other.as_str())
+ }
+}
+
+impl PartialEq<Value> for String {
+ fn eq(&self, other: &Value) -> bool {
+ eq_str(other, self.as_str())
+ }
+}
+
+macro_rules! partialeq_numeric {
+ ($($eq:ident [$($ty:ty)*])*) => {
+ $($(
+ impl PartialEq<$ty> for Value {
+ fn eq(&self, other: &$ty) -> bool {
+ $eq(self, *other as _)
+ }
+ }
+
+ impl PartialEq<Value> for $ty {
+ fn eq(&self, other: &Value) -> bool {
+ $eq(other, *self as _)
+ }
+ }
+
+ impl<'a> PartialEq<$ty> for &'a Value {
+ fn eq(&self, other: &$ty) -> bool {
+ $eq(*self, *other as _)
+ }
+ }
+
+ impl<'a> PartialEq<$ty> for &'a mut Value {
+ fn eq(&self, other: &$ty) -> bool {
+ $eq(*self, *other as _)
+ }
+ }
+ )*)*
+ }
+}
+
+partialeq_numeric! {
+ eq_i64[i8 i16 i32 i64 isize]
+ eq_u64[u8 u16 u32 u64 usize]
+ eq_f64[f32 f64]
+ eq_bool[bool]
+}
new file mode 100644
--- /dev/null
+++ b/third_party/rust/serde_json/src/value/ser.rs
@@ -0,0 +1,827 @@
+// Copyright 2017 Serde Developers
+//
+// Licensed under the Apache License, Version 2.0 <LICENSE-APACHE or
+// http://www.apache.org/licenses/LICENSE-2.0> or the MIT license
+// <LICENSE-MIT or http://opensource.org/licenses/MIT>, at your
+// option. This file may not be copied, modified, or distributed
+// except according to those terms.
+
+use serde::ser::Impossible;
+use serde::{self, Serialize};
+
+use error::{Error, ErrorCode};
+use map::Map;
+use number::Number;
+use value::{to_value, Value};
+
+#[cfg(feature = "arbitrary_precision")]
+use serde::ser;
+
+#[cfg(feature = "arbitrary_precision")]
+use number::{SERDE_STRUCT_FIELD_NAME, SERDE_STRUCT_NAME};
+
+impl Serialize for Value {
+ #[inline]
+ fn serialize<S>(&self, serializer: S) -> Result<S::Ok, S::Error>
+ where
+ S: ::serde::Serializer,
+ {
+ match *self {
+ Value::Null => serializer.serialize_unit(),
+ Value::Bool(b) => serializer.serialize_bool(b),
+ Value::Number(ref n) => n.serialize(serializer),
+ Value::String(ref s) => serializer.serialize_str(s),
+ Value::Array(ref v) => v.serialize(serializer),
+ Value::Object(ref m) => {
+ use serde::ser::SerializeMap;
+ let mut map = try!(serializer.serialize_map(Some(m.len())));
+ for (k, v) in m {
+ try!(map.serialize_key(k));
+ try!(map.serialize_value(v));
+ }
+ map.end()
+ }
+ }
+ }
+}
+
+pub struct Serializer;
+
+impl serde::Serializer for Serializer {
+ type Ok = Value;
+ type Error = Error;
+
+ type SerializeSeq = SerializeVec;
+ type SerializeTuple = SerializeVec;
+ type SerializeTupleStruct = SerializeVec;
+ type SerializeTupleVariant = SerializeTupleVariant;
+ type SerializeMap = SerializeMap;
+ type SerializeStruct = SerializeMap;
+ type SerializeStructVariant = SerializeStructVariant;
+
+ #[inline]
+ fn serialize_bool(self, value: bool) -> Result<Value, Error> {
+ Ok(Value::Bool(value))
+ }
+
+ #[inline]
+ fn serialize_i8(self, value: i8) -> Result<Value, Error> {
+ self.serialize_i64(value as i64)
+ }
+
+ #[inline]
+ fn serialize_i16(self, value: i16) -> Result<Value, Error> {
+ self.serialize_i64(value as i64)
+ }
+
+ #[inline]
+ fn serialize_i32(self, value: i32) -> Result<Value, Error> {
+ self.serialize_i64(value as i64)
+ }
+
+ fn serialize_i64(self, value: i64) -> Result<Value, Error> {
+ Ok(Value::Number(value.into()))
+ }
+
+ #[inline]
+ fn serialize_u8(self, value: u8) -> Result<Value, Error> {
+ self.serialize_u64(value as u64)
+ }
+
+ #[inline]
+ fn serialize_u16(self, value: u16) -> Result<Value, Error> {
+ self.serialize_u64(value as u64)
+ }
+
+ #[inline]
+ fn serialize_u32(self, value: u32) -> Result<Value, Error> {
+ self.serialize_u64(value as u64)
+ }
+
+ #[inline]
+ fn serialize_u64(self, value: u64) -> Result<Value, Error> {
+ Ok(Value::Number(value.into()))
+ }
+
+ #[inline]
+ fn serialize_f32(self, value: f32) -> Result<Value, Error> {
+ self.serialize_f64(value as f64)
+ }
+
+ #[inline]
+ fn serialize_f64(self, value: f64) -> Result<Value, Error> {
+ Ok(Number::from_f64(value).map_or(Value::Null, Value::Number))
+ }
+
+ #[inline]
+ fn serialize_char(self, value: char) -> Result<Value, Error> {
+ let mut s = String::new();
+ s.push(value);
+ self.serialize_str(&s)
+ }
+
+ #[inline]
+ fn serialize_str(self, value: &str) -> Result<Value, Error> {
+ Ok(Value::String(value.to_owned()))
+ }
+
+ fn serialize_bytes(self, value: &[u8]) -> Result<Value, Error> {
+ let vec = value.iter().map(|&b| Value::Number(b.into())).collect();
+ Ok(Value::Array(vec))
+ }
+
+ #[inline]
+ fn serialize_unit(self) -> Result<Value, Error> {
+ Ok(Value::Null)
+ }
+
+ #[inline]
+ fn serialize_unit_struct(self, _name: &'static str) -> Result<Value, Error> {
+ self.serialize_unit()
+ }
+
+ #[inline]
+ fn serialize_unit_variant(
+ self,
+ _name: &'static str,
+ _variant_index: u32,
+ variant: &'static str,
+ ) -> Result<Value, Error> {
+ self.serialize_str(variant)
+ }
+
+ #[inline]
+ fn serialize_newtype_struct<T: ?Sized>(
+ self,
+ _name: &'static str,
+ value: &T,
+ ) -> Result<Value, Error>
+ where
+ T: Serialize,
+ {
+ value.serialize(self)
+ }
+
+ fn serialize_newtype_variant<T: ?Sized>(
+ self,
+ _name: &'static str,
+ _variant_index: u32,
+ variant: &'static str,
+ value: &T,
+ ) -> Result<Value, Error>
+ where
+ T: Serialize,
+ {
+ let mut values = Map::new();
+ values.insert(String::from(variant), try!(to_value(&value)));
+ Ok(Value::Object(values))
+ }
+
+ #[inline]
+ fn serialize_none(self) -> Result<Value, Error> {
+ self.serialize_unit()
+ }
+
+ #[inline]
+ fn serialize_some<T: ?Sized>(self, value: &T) -> Result<Value, Error>
+ where
+ T: Serialize,
+ {
+ value.serialize(self)
+ }
+
+ fn serialize_seq(self, len: Option<usize>) -> Result<Self::SerializeSeq, Error> {
+ Ok(SerializeVec {
+ vec: Vec::with_capacity(len.unwrap_or(0)),
+ })
+ }
+
+ fn serialize_tuple(self, len: usize) -> Result<Self::SerializeTuple, Error> {
+ self.serialize_seq(Some(len))
+ }
+
+ fn serialize_tuple_struct(
+ self,
+ _name: &'static str,
+ len: usize,
+ ) -> Result<Self::SerializeTupleStruct, Error> {
+ self.serialize_seq(Some(len))
+ }
+
+ fn serialize_tuple_variant(
+ self,
+ _name: &'static str,
+ _variant_index: u32,
+ variant: &'static str,
+ len: usize,
+ ) -> Result<Self::SerializeTupleVariant, Error> {
+ Ok(SerializeTupleVariant {
+ name: String::from(variant),
+ vec: Vec::with_capacity(len),
+ })
+ }
+
+ fn serialize_map(self, _len: Option<usize>) -> Result<Self::SerializeMap, Error> {
+ Ok(SerializeMap::Map {
+ map: Map::new(),
+ next_key: None,
+ })
+ }
+
+ #[cfg(not(feature = "arbitrary_precision"))]
+ fn serialize_struct(
+ self,
+ _name: &'static str,
+ len: usize,
+ ) -> Result<Self::SerializeStruct, Error> {
+ self.serialize_map(Some(len))
+ }
+
+ #[cfg(feature = "arbitrary_precision")]
+ fn serialize_struct(
+ self,
+ name: &'static str,
+ len: usize,
+ ) -> Result<Self::SerializeStruct, Error> {
+ if name == SERDE_STRUCT_NAME {
+ Ok(SerializeMap::Number { out_value: None })
+ } else {
+ self.serialize_map(Some(len))
+ }
+ }
+
+ fn serialize_struct_variant(
+ self,
+ _name: &'static str,
+ _variant_index: u32,
+ variant: &'static str,
+ _len: usize,
+ ) -> Result<Self::SerializeStructVariant, Error> {
+ Ok(SerializeStructVariant {
+ name: String::from(variant),
+ map: Map::new(),
+ })
+ }
+}
+
+pub struct SerializeVec {
+ vec: Vec<Value>,
+}
+
+pub struct SerializeTupleVariant {
+ name: String,
+ vec: Vec<Value>,
+}
+
+pub enum SerializeMap {
+ Map {
+ map: Map<String, Value>,
+ next_key: Option<String>,
+ },
+ #[cfg(feature = "arbitrary_precision")]
+ Number { out_value: Option<Value> },
+}
+
+pub struct SerializeStructVariant {
+ name: String,
+ map: Map<String, Value>,
+}
+
+impl serde::ser::SerializeSeq for SerializeVec {
+ type Ok = Value;
+ type Error = Error;
+
+ fn serialize_element<T: ?Sized>(&mut self, value: &T) -> Result<(), Error>
+ where
+ T: Serialize,
+ {
+ self.vec.push(try!(to_value(&value)));
+ Ok(())
+ }
+
+ fn end(self) -> Result<Value, Error> {
+ Ok(Value::Array(self.vec))
+ }
+}
+
+impl serde::ser::SerializeTuple for SerializeVec {
+ type Ok = Value;
+ type Error = Error;
+
+ fn serialize_element<T: ?Sized>(&mut self, value: &T) -> Result<(), Error>
+ where
+ T: Serialize,
+ {
+ serde::ser::SerializeSeq::serialize_element(self, value)
+ }
+
+ fn end(self) -> Result<Value, Error> {
+ serde::ser::SerializeSeq::end(self)
+ }
+}
+
+impl serde::ser::SerializeTupleStruct for SerializeVec {
+ type Ok = Value;
+ type Error = Error;
+
+ fn serialize_field<T: ?Sized>(&mut self, value: &T) -> Result<(), Error>
+ where
+ T: Serialize,
+ {
+ serde::ser::SerializeSeq::serialize_element(self, value)
+ }
+
+ fn end(self) -> Result<Value, Error> {
+ serde::ser::SerializeSeq::end(self)
+ }
+}
+
+impl serde::ser::SerializeTupleVariant for SerializeTupleVariant {
+ type Ok = Value;
+ type Error = Error;
+
+ fn serialize_field<T: ?Sized>(&mut self, value: &T) -> Result<(), Error>
+ where
+ T: Serialize,
+ {
+ self.vec.push(try!(to_value(&value)));
+ Ok(())
+ }
+
+ fn end(self) -> Result<Value, Error> {
+ let mut object = Map::new();
+
+ object.insert(self.name, Value::Array(self.vec));
+
+ Ok(Value::Object(object))
+ }
+}
+
+impl serde::ser::SerializeMap for SerializeMap {
+ type Ok = Value;
+ type Error = Error;
+
+ fn serialize_key<T: ?Sized>(&mut self, key: &T) -> Result<(), Error>
+ where
+ T: Serialize,
+ {
+ match *self {
+ SerializeMap::Map {
+ ref mut next_key, ..
+ } => {
+ *next_key = Some(try!(key.serialize(MapKeySerializer)));
+ Ok(())
+ }
+ #[cfg(feature = "arbitrary_precision")]
+ SerializeMap::Number { .. } => unreachable!(),
+ }
+ }
+
+ fn serialize_value<T: ?Sized>(&mut self, value: &T) -> Result<(), Error>
+ where
+ T: Serialize,
+ {
+ match *self {
+ SerializeMap::Map {
+ ref mut map,
+ ref mut next_key,
+ } => {
+ let key = next_key.take();
+ // Panic because this indicates a bug in the program rather than an
+ // expected failure.
+ let key = key.expect("serialize_value called before serialize_key");
+ map.insert(key, try!(to_value(&value)));
+ Ok(())
+ }
+ #[cfg(feature = "arbitrary_precision")]
+ SerializeMap::Number { .. } => unreachable!(),
+ }
+ }
+
+ fn end(self) -> Result<Value, Error> {
+ match self {
+ SerializeMap::Map { map, .. } => Ok(Value::Object(map)),
+ #[cfg(feature = "arbitrary_precision")]
+ SerializeMap::Number { .. } => unreachable!(),
+ }
+ }
+}
+
+struct MapKeySerializer;
+
+fn key_must_be_a_string() -> Error {
+ Error::syntax(ErrorCode::KeyMustBeAString, 0, 0)
+}
+
+impl serde::Serializer for MapKeySerializer {
+ type Ok = String;
+ type Error = Error;
+
+ type SerializeSeq = Impossible<String, Error>;
+ type SerializeTuple = Impossible<String, Error>;
+ type SerializeTupleStruct = Impossible<String, Error>;
+ type SerializeTupleVariant = Impossible<String, Error>;
+ type SerializeMap = Impossible<String, Error>;
+ type SerializeStruct = Impossible<String, Error>;
+ type SerializeStructVariant = Impossible<String, Error>;
+
+ #[inline]
+ fn serialize_unit_variant(
+ self,
+ _name: &'static str,
+ _variant_index: u32,
+ variant: &'static str,
+ ) -> Result<Self::Ok, Self::Error> {
+ Ok(variant.to_owned())
+ }
+
+ #[inline]
+ fn serialize_newtype_struct<T: ?Sized>(
+ self,
+ _name: &'static str,
+ value: &T,
+ ) -> Result<Self::Ok, Self::Error>
+ where
+ T: Serialize,
+ {
+ value.serialize(self)
+ }
+
+ fn serialize_bool(self, _value: bool) -> Result<Self::Ok, Self::Error> {
+ Err(key_must_be_a_string())
+ }
+
+ fn serialize_i8(self, value: i8) -> Result<Self::Ok, Self::Error> {
+ Ok(value.to_string())
+ }
+
+ fn serialize_i16(self, value: i16) -> Result<Self::Ok, Self::Error> {
+ Ok(value.to_string())
+ }
+
+ fn serialize_i32(self, value: i32) -> Result<Self::Ok, Self::Error> {
+ Ok(value.to_string())
+ }
+
+ fn serialize_i64(self, value: i64) -> Result<Self::Ok, Self::Error> {
+ Ok(value.to_string())
+ }
+
+ fn serialize_u8(self, value: u8) -> Result<Self::Ok, Self::Error> {
+ Ok(value.to_string())
+ }
+
+ fn serialize_u16(self, value: u16) -> Result<Self::Ok, Self::Error> {
+ Ok(value.to_string())
+ }
+
+ fn serialize_u32(self, value: u32) -> Result<Self::Ok, Self::Error> {
+ Ok(value.to_string())
+ }
+
+ fn serialize_u64(self, value: u64) -> Result<Self::Ok, Self::Error> {
+ Ok(value.to_string())
+ }
+
+ fn serialize_f32(self, _value: f32) -> Result<Self::Ok, Self::Error> {
+ Err(key_must_be_a_string())
+ }
+
+ fn serialize_f64(self, _value: f64) -> Result<Self::Ok, Self::Error> {
+ Err(key_must_be_a_string())
+ }
+
+ #[inline]
+ fn serialize_char(self, value: char) -> Result<Self::Ok, Self::Error> {
+ Ok({
+ let mut s = String::new();
+ s.push(value);
+ s
+ })
+ }
+
+ #[inline]
+ fn serialize_str(self, value: &str) -> Result<Self::Ok, Self::Error> {
+ Ok(value.to_owned())
+ }
+
+ fn serialize_bytes(self, _value: &[u8]) -> Result<Self::Ok, Self::Error> {
+ Err(key_must_be_a_string())
+ }
+
+ fn serialize_unit(self) -> Result<Self::Ok, Self::Error> {
+ Err(key_must_be_a_string())
+ }
+
+ fn serialize_unit_struct(self, _name: &'static str) -> Result<Self::Ok, Self::Error> {
+ Err(key_must_be_a_string())
+ }
+
+ fn serialize_newtype_variant<T: ?Sized>(
+ self,
+ _name: &'static str,
+ _variant_index: u32,
+ _variant: &'static str,
+ _value: &T,
+ ) -> Result<Self::Ok, Self::Error>
+ where
+ T: Serialize,
+ {
+ Err(key_must_be_a_string())
+ }
+
+ fn serialize_none(self) -> Result<Self::Ok, Self::Error> {
+ Err(key_must_be_a_string())
+ }
+
+ fn serialize_some<T: ?Sized>(self, _value: &T) -> Result<Self::Ok, Self::Error>
+ where
+ T: Serialize,
+ {
+ Err(key_must_be_a_string())
+ }
+
+ fn serialize_seq(self, _len: Option<usize>) -> Result<Self::SerializeSeq, Self::Error> {
+ Err(key_must_be_a_string())
+ }
+
+ fn serialize_tuple(self, _len: usize) -> Result<Self::SerializeTuple, Self::Error> {
+ Err(key_must_be_a_string())
+ }
+
+ fn serialize_tuple_struct(
+ self,
+ _name: &'static str,
+ _len: usize,
+ ) -> Result<Self::SerializeTupleStruct, Self::Error> {
+ Err(key_must_be_a_string())
+ }
+
+ fn serialize_tuple_variant(
+ self,
+ _name: &'static str,
+ _variant_index: u32,
+ _variant: &'static str,
+ _len: usize,
+ ) -> Result<Self::SerializeTupleVariant, Self::Error> {
+ Err(key_must_be_a_string())
+ }
+
+ fn serialize_map(self, _len: Option<usize>) -> Result<Self::SerializeMap, Self::Error> {
+ Err(key_must_be_a_string())
+ }
+
+ fn serialize_struct(
+ self,
+ _name: &'static str,
+ _len: usize,
+ ) -> Result<Self::SerializeStruct, Self::Error> {
+ Err(key_must_be_a_string())
+ }
+
+ fn serialize_struct_variant(
+ self,
+ _name: &'static str,
+ _variant_index: u32,
+ _variant: &'static str,
+ _len: usize,
+ ) -> Result<Self::SerializeStructVariant, Self::Error> {
+ Err(key_must_be_a_string())
+ }
+}
+
+impl serde::ser::SerializeStruct for SerializeMap {
+ type Ok = Value;
+ type Error = Error;
+
+ fn serialize_field<T: ?Sized>(&mut self, key: &'static str, value: &T) -> Result<(), Error>
+ where
+ T: Serialize,
+ {
+ match *self {
+ SerializeMap::Map { .. } => {
+ try!(serde::ser::SerializeMap::serialize_key(self, key));
+ serde::ser::SerializeMap::serialize_value(self, value)
+ }
+ #[cfg(feature = "arbitrary_precision")]
+ SerializeMap::Number { ref mut out_value } => {
+ if key == SERDE_STRUCT_FIELD_NAME {
+ *out_value = Some(value.serialize(NumberValueEmitter)?);
+ Ok(())
+ } else {
+ Err(invalid_number())
+ }
+ }
+ }
+ }
+
+ fn end(self) -> Result<Value, Error> {
+ match self {
+ SerializeMap::Map { .. } => serde::ser::SerializeMap::end(self),
+ #[cfg(feature = "arbitrary_precision")]
+ SerializeMap::Number { out_value, .. } => {
+ Ok(out_value.expect("number value was not emitted"))
+ }
+ }
+ }
+}
+
+impl serde::ser::SerializeStructVariant for SerializeStructVariant {
+ type Ok = Value;
+ type Error = Error;
+
+ fn serialize_field<T: ?Sized>(&mut self, key: &'static str, value: &T) -> Result<(), Error>
+ where
+ T: Serialize,
+ {
+ self.map.insert(String::from(key), try!(to_value(&value)));
+ Ok(())
+ }
+
+ fn end(self) -> Result<Value, Error> {
+ let mut object = Map::new();
+
+ object.insert(self.name, Value::Object(self.map));
+
+ Ok(Value::Object(object))
+ }
+}
+
+#[cfg(feature = "arbitrary_precision")]
+struct NumberValueEmitter;
+
+#[cfg(feature = "arbitrary_precision")]
+fn invalid_number() -> Error {
+ Error::syntax(ErrorCode::InvalidNumber, 0, 0)
+}
+
+#[cfg(feature = "arbitrary_precision")]
+impl ser::Serializer for NumberValueEmitter {
+ type Ok = Value;
+ type Error = Error;
+
+ type SerializeSeq = Impossible<Value, Error>;
+ type SerializeTuple = Impossible<Value, Error>;
+ type SerializeTupleStruct = Impossible<Value, Error>;
+ type SerializeTupleVariant = Impossible<Value, Error>;
+ type SerializeMap = Impossible<Value, Error>;
+ type SerializeStruct = Impossible<Value, Error>;
+ type SerializeStructVariant = Impossible<Value, Error>;
+
+ fn serialize_bool(self, _v: bool) -> Result<Self::Ok, Self::Error> {
+ Err(invalid_number())
+ }
+
+ fn serialize_i8(self, _v: i8) -> Result<Self::Ok, Self::Error> {
+ Err(invalid_number())
+ }
+
+ fn serialize_i16(self, _v: i16) -> Result<Self::Ok, Self::Error> {
+ Err(invalid_number())
+ }
+
+ fn serialize_i32(self, _v: i32) -> Result<Self::Ok, Self::Error> {
+ Err(invalid_number())
+ }
+
+ fn serialize_i64(self, _v: i64) -> Result<Self::Ok, Self::Error> {
+ Err(invalid_number())
+ }
+
+ fn serialize_u8(self, _v: u8) -> Result<Self::Ok, Self::Error> {
+ Err(invalid_number())
+ }
+
+ fn serialize_u16(self, _v: u16) -> Result<Self::Ok, Self::Error> {
+ Err(invalid_number())
+ }
+
+ fn serialize_u32(self, _v: u32) -> Result<Self::Ok, Self::Error> {
+ Err(invalid_number())
+ }
+
+ fn serialize_u64(self, _v: u64) -> Result<Self::Ok, Self::Error> {
+ Err(invalid_number())
+ }
+
+ fn serialize_f32(self, _v: f32) -> Result<Self::Ok, Self::Error> {
+ Err(invalid_number())
+ }
+
+ fn serialize_f64(self, _v: f64) -> Result<Self::Ok, Self::Error> {
+ Err(invalid_number())
+ }
+
+ fn serialize_char(self, _v: char) -> Result<Self::Ok, Self::Error> {
+ Err(invalid_number())
+ }
+
+ fn serialize_str(self, value: &str) -> Result<Self::Ok, Self::Error> {
+ let n = try!(value.to_owned().parse());
+ Ok(Value::Number(n))
+ }
+
+ fn serialize_bytes(self, _value: &[u8]) -> Result<Self::Ok, Self::Error> {
+ Err(invalid_number())
+ }
+
+ fn serialize_none(self) -> Result<Self::Ok, Self::Error> {
+ Err(invalid_number())
+ }
+
+ fn serialize_some<T: ?Sized>(self, _value: &T) -> Result<Self::Ok, Self::Error>
+ where
+ T: Serialize,
+ {
+ Err(invalid_number())
+ }
+
+ fn serialize_unit(self) -> Result<Self::Ok, Self::Error> {
+ Err(invalid_number())
+ }
+
+ fn serialize_unit_struct(self, _name: &'static str) -> Result<Self::Ok, Self::Error> {
+ Err(invalid_number())
+ }
+
+ fn serialize_unit_variant(
+ self,
+ _name: &'static str,
+ _variant_index: u32,
+ _variant: &'static str,
+ ) -> Result<Self::Ok, Self::Error> {
+ Err(invalid_number())
+ }
+
+ fn serialize_newtype_struct<T: ?Sized>(
+ self,
+ _name: &'static str,
+ _value: &T,
+ ) -> Result<Self::Ok, Self::Error>
+ where
+ T: Serialize,
+ {
+ Err(invalid_number())
+ }
+
+ fn serialize_newtype_variant<T: ?Sized>(
+ self,
+ _name: &'static str,
+ _variant_index: u32,
+ _variant: &'static str,
+ _value: &T,
+ ) -> Result<Self::Ok, Self::Error>
+ where
+ T: Serialize,
+ {
+ Err(invalid_number())
+ }
+
+ fn serialize_seq(self, _len: Option<usize>) -> Result<Self::SerializeSeq, Self::Error> {
+ Err(invalid_number())
+ }
+
+ fn serialize_tuple(self, _len: usize) -> Result<Self::SerializeTuple, Self::Error> {
+ Err(invalid_number())
+ }
+
+ fn serialize_tuple_struct(
+ self,
+ _name: &'static str,
+ _len: usize,
+ ) -> Result<Self::SerializeTupleStruct, Self::Error> {
+ Err(invalid_number())
+ }
+
+ fn serialize_tuple_variant(
+ self,
+ _name: &'static str,
+ _variant_index: u32,
+ _variant: &'static str,
+ _len: usize,
+ ) -> Result<Self::SerializeTupleVariant, Self::Error> {
+ Err(invalid_number())
+ }
+
+ fn serialize_map(self, _len: Option<usize>) -> Result<Self::SerializeMap, Self::Error> {
+ Err(invalid_number())
+ }
+
+ fn serialize_struct(
+ self,
+ _name: &'static str,
+ _len: usize,
+ ) -> Result<Self::SerializeStruct, Self::Error> {
+ Err(invalid_number())
+ }
+
+ fn serialize_struct_variant(
+ self,
+ _name: &'static str,
+ _variant_index: u32,
+ _variant: &'static str,
+ _len: usize,
+ ) -> Result<Self::SerializeStructVariant, Self::Error> {
+ Err(invalid_number())
+ }
+}