[rust-3p] Update eui48 to 1.1.0
This also removes rustc-serialize, which isn't used inside fuchsia.
Change-Id: I0de234e2274590bc4a32ec25d12ed9bc8432bd27
Reviewed-on: https://fuchsia-review.googlesource.com/c/fuchsia/+/693875
Reviewed-by: Erick Tryzelaar <etryzelaar@google.com>
Reviewed-by: Dan Johnson <computerdruid@google.com>
Fuchsia-Auto-Submit: Erick Tryzelaar <etryzelaar@google.com>
Commit-Queue: Auto-Submit <auto-submit@fuchsia-infra.iam.gserviceaccount.com>
diff --git a/third_party/rust_crates/BUILD.gn b/third_party/rust_crates/BUILD.gn
index 422ec14..568056f 100644
--- a/third_party/rust_crates/BUILD.gn
+++ b/third_party/rust_crates/BUILD.gn
@@ -253,7 +253,7 @@
}
group("eui48") {
- public_deps = [ ":eui48-v0_4_6" ]
+ public_deps = [ ":eui48-v1_1_0" ]
}
group("event-listener") {
@@ -3890,14 +3890,14 @@
visibility = [ ":*" ]
}
-rust_library("eui48-v0_4_6") {
+rust_library("eui48-v1_1_0") {
crate_name = "eui48"
crate_root = "//third_party/rust_crates/vendor/eui48/src/lib.rs"
- output_name = "eui48-82065d8958fea295"
+ output_name = "eui48-311e12b917d0daa"
configs -= [ "//build/config/rust:2018_idioms" ]
deps = []
- deps += [ ":rustc-serialize-v0_3_24" ]
+ deps += [ ":regex-v1_5_6" ]
deps += [ ":serde-v1_0_116" ]
rustenv = []
@@ -3905,9 +3905,8 @@
rustflags = [
"--cap-lints=allow",
"--edition=2018",
- "-Cmetadata=82065d8958fea295",
- "-Cextra-filename=-82065d8958fea295",
- "--cfg=feature=\"default\"",
+ "-Cmetadata=311e12b917d0daa",
+ "-Cextra-filename=-311e12b917d0daa",
"--cfg=feature=\"disp_hexstring\"",
"--cfg=feature=\"serde\"",
]
@@ -8841,26 +8840,6 @@
visibility = [ ":*" ]
}
-rust_library("rustc-serialize-v0_3_24") {
- crate_name = "rustc_serialize"
- crate_root = "//third_party/rust_crates/vendor/rustc-serialize/src/lib.rs"
- output_name = "rustc_serialize-cf1d65d911e642f1"
- configs -= [ "//build/config/rust:2018_idioms" ]
-
- deps = []
-
- rustenv = []
-
- rustflags = [
- "--cap-lints=allow",
- "--edition=2015",
- "-Cmetadata=cf1d65d911e642f1",
- "-Cextra-filename=-cf1d65d911e642f1",
- ]
-
- visibility = [ ":*" ]
-}
-
rust_library("rustfix-v0_6_1") {
crate_name = "rustfix"
crate_root = "//third_party/rust_crates/vendor/rustfix/src/lib.rs"
diff --git a/third_party/rust_crates/Cargo.lock b/third_party/rust_crates/Cargo.lock
index e419e87..c1d7a9e 100644
--- a/third_party/rust_crates/Cargo.lock
+++ b/third_party/rust_crates/Cargo.lock
@@ -1172,11 +1172,11 @@
[[package]]
name = "eui48"
-version = "0.4.6"
+version = "1.1.0"
source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "8c4cf866e4d3e5e773691f5f61615a224a7b0b72b7daf994fc56d1b82dab0b6b"
+checksum = "887418ac5e8d57c2e66e04bdc2fe15f9a5407be20b54a82c86bd0e368b709701"
dependencies = [
- "rustc-serialize",
+ "regex",
"serde",
]
@@ -3408,12 +3408,6 @@
]
[[package]]
-name = "rustc-serialize"
-version = "0.3.24"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "dcf128d1287d2ea9d80910b5f1120d0b8eede3fbf1abe91c40d39ea7d51e6fda"
-
-[[package]]
name = "rustc_version"
version = "0.2.3"
source = "registry+https://github.com/rust-lang/crates.io-index"
diff --git a/third_party/rust_crates/Cargo.toml b/third_party/rust_crates/Cargo.toml
index 34ecfb6..02d6c21 100644
--- a/third_party/rust_crates/Cargo.toml
+++ b/third_party/rust_crates/Cargo.toml
@@ -87,7 +87,7 @@
ecdsa = "0.13.4"
elliptic-curve = { version = "0.11.12", features = [ "ecdh" ] }
either = "1.5.0"
-eui48 = { version = "0.4.6", features = ["serde", "disp_hexstring"] }
+eui48 = { version = "1.1.0", default-features = false, features = ["serde", "disp_hexstring"] }
event-listener = "2.5.1"
fatfs = { path = "forks/fatfs" }
flate2 = { version = "1.0.14", default-features = false, features = ["rust_backend"] }
diff --git a/third_party/rust_crates/vendor/eui48/.cargo-checksum.json b/third_party/rust_crates/vendor/eui48/.cargo-checksum.json
index 04795d6..6c10a1e 100644
--- a/third_party/rust_crates/vendor/eui48/.cargo-checksum.json
+++ b/third_party/rust_crates/vendor/eui48/.cargo-checksum.json
@@ -1 +1 @@
-{"files":{"Cargo.toml":"da63b33db3a5b490825f7a3cfe254d3caaa59a7c770701a3e8570e806a9c3b38","LICENSE-APACHE":"a60eea817514531668d7e00765731449fe14d059d3249e0bc93b36de45f759f2","LICENSE-MIT":"23f18e03dc49df91622fe2a76176497404e46ced8a715d9d2b67a7446571cca3","README.md":"02af74eaa9f1345a41ebe1bf3eeb05204440c09bbaebdde5f919b6eb16048cc3","README.tpl":"95044f8dd6a0c8319cc4ed0000f9be745c603c371e646712852956f3451e4547","appveyor.yml":"8c07196d8796b458689a2f69b6937f32f3a6f240211065a15bf8cbbd198bd7c7","src/lib.rs":"77d65925adc35fa5dfb7516f4ed8facbf202a9e9defd947497b6fe9441e79cf1"},"package":"8c4cf866e4d3e5e773691f5f61615a224a7b0b72b7daf994fc56d1b82dab0b6b"}
\ No newline at end of file
+{"files":{"Cargo.toml":"cdda23cc06e9d2be2c61ca3816c9fe7951ea8382ac1afeee19ed1279c4e05bd0","LICENSE-APACHE":"a60eea817514531668d7e00765731449fe14d059d3249e0bc93b36de45f759f2","LICENSE-MIT":"23f18e03dc49df91622fe2a76176497404e46ced8a715d9d2b67a7446571cca3","README.md":"8e6fe99599163a53b5662ae266beec8025ec9eba2efa5c254bb07096c488b1b8","README.tpl":"95044f8dd6a0c8319cc4ed0000f9be745c603c371e646712852956f3451e4547","appveyor.yml":"8c07196d8796b458689a2f69b6937f32f3a6f240211065a15bf8cbbd198bd7c7","src/lib.rs":"9e0af9401f10ab01c48f47201f687857b0d72264f286cff30397c528539be227"},"package":"887418ac5e8d57c2e66e04bdc2fe15f9a5407be20b54a82c86bd0e368b709701"}
\ No newline at end of file
diff --git a/third_party/rust_crates/vendor/eui48/Cargo.toml b/third_party/rust_crates/vendor/eui48/Cargo.toml
index 7d76104..7987aea 100644
--- a/third_party/rust_crates/vendor/eui48/Cargo.toml
+++ b/third_party/rust_crates/vendor/eui48/Cargo.toml
@@ -3,7 +3,7 @@
# 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
+# 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
@@ -13,8 +13,8 @@
[package]
edition = "2018"
name = "eui48"
-version = "0.4.6"
-authors = ["Andrew Baumhauer <andy@baumhauer.us>", "<rlcomstock3@github.com>", "Michal 'vorner' Vaner <vorner+github@vorner.cz>"]
+version = "1.1.0"
+authors = ["Andrew Baumhauer <andy@baumhauer.us>", "<rlcomstock3@github.com>", "Michal 'vorner' Vaner <vorner+github@vorner.cz>", "Stan Drozd <drozdziak1@gmail.com>"]
exclude = [".gitignore", ".travis.yml", ".gitlab-ci.yml", ".travis/*"]
description = "A library to generate and parse IEEE EUI-48 and EUI-64, also known as MAC-48 media access\ncontrol addresses. The IEEE claims trademarks on the names EUI-48 and EUI-64, in which EUI is an\nabbreviation for Extended Unique Identifier.\n"
homepage = "https://github.com/abaumhauer/eui48"
@@ -23,20 +23,28 @@
categories = ["network-programming", "parser-implementations"]
license = "MIT/Apache-2.0"
repository = "https://github.com/abaumhauer/eui48"
+[dependencies.regex]
+version = "1.3.9"
+optional = false
+
[dependencies.rustc-serialize]
version = "0.3.24"
+optional = true
[dependencies.serde]
-version = "1.0.80"
+version = "1.0.114"
optional = true
[dependencies.serde_json]
-version = "1.0.37"
+version = "1.0.56"
optional = true
+[dev-dependencies.bincode]
+version = "1.3.1"
[features]
-default = []
+default = ["rustc-serialize"]
disp_hexstring = []
+serde_bytes = ["serde"]
[badges.appveyor]
branch = "master"
repository = "abaumhauer/eui48"
diff --git a/third_party/rust_crates/vendor/eui48/README.md b/third_party/rust_crates/vendor/eui48/README.md
index f9b76fe..82b9b83 100644
--- a/third_party/rust_crates/vendor/eui48/README.md
+++ b/third_party/rust_crates/vendor/eui48/README.md
@@ -17,7 +17,7 @@
```toml
[dependencies]
-eui48 = "0.4.6"
+eui48 = "1.0.1"
```
and this to your crate root:
@@ -52,6 +52,19 @@
}
```
+## Notes
+* The default display format is cannonical form `01-02-03-04-05-06` unless a compile time feature `disp_hexstring` is enabled, then the default format is of the form `01:02:03:04:05:06`.
+
+Version 1.0.0 and above allows a more flexible parsing of MAC address strings, compliments of Stan Drozd:
+* Enables the library's caller to parse the MACs that don't follow fixed-length MAC address convention (I'm looking at you, ebtables!). In general, the parsing function tries harder to interpret a given string than before.
+* Rewrite parse_str to use a regex and be more lenient (now it permits one-off string chopping errors and mixed delimiters are accepted as long as we manage to read 6 bytes)
+* Exchange the InvalidCharacter error enum value for InvalidByteCount - InvalidCharacter is no longer supported. See versions >=0.5.0 and < 1.0.0 if you need legacy behavior.
+
+## Serialization
+When using `serde` to serialize a MAC address the address is stored as a formatted string. This fits well for text-based protocols like JSON but creates overhead for binary serialization. The overhead gets even bigger when the string is deserialized again, as a full-grown parser is needed instead of reading raw bytes. To reduce this overhead use the `serde_bytes` feature when serializing and deserializing MAC addresses to binary protocols.
+
+NOTE: `serde_bytes` and `serde_json` are mutually exclusive!
+
## References
[Wikipedia: MAC address](https://en.wikipedia.org/wiki/MAC_address)
@@ -67,3 +80,11 @@
- 0.4.4 Andrew Baumhauer - Update documentation
- 0.4.5 Andrew Baumhauer - Improve code coverage and tests
- 0.4.6 Jiwoong Lee - Add to_array() for compatibility, add feature disp_hexstring
+- 0.4.7 Adam Reichold - WASM updates
+- 0.4.8 @kamek-pf - respect disp_hexstring flag
+- 0.4.9 Sebastian Dietze - New const added
+- 0.5.0 Andrew Baumhauer - cleanup, update versions, fmt, merge PRs, update unit tests
+- 0.5.1 jrb0001 - Fixed incorrect IPv6 to_link_local for Link-Scoped Unicast
+- 1.0.0 Stan Drozd, @rlcomstock3, and Andrew Baumhauer - merged all forks and improvements back to this repo
+- 1.0.1 jrb0001 - Fixed incorrect IPv6 to_link_local for Link-Scoped Unicast
+- 1.1.0 Felix Schreiner - binary serialization optimization
diff --git a/third_party/rust_crates/vendor/eui48/src/lib.rs b/third_party/rust_crates/vendor/eui48/src/lib.rs
index a9a3ee7..58dba71 100644
--- a/third_party/rust_crates/vendor/eui48/src/lib.rs
+++ b/third_party/rust_crates/vendor/eui48/src/lib.rs
@@ -15,8 +15,9 @@
html_favicon_url = "https://www.rust-lang.org/favicon.ico",
html_root_url = "https://doc.rust-lang.org/eui48/"
)]
-#![cfg_attr(test, deny(warnings))]
+extern crate regex;
+#[cfg(feature = "rustc-serialize")]
extern crate rustc_serialize;
#[cfg(feature = "serde")]
extern crate serde;
@@ -28,6 +29,8 @@
use std::fmt;
use std::str::FromStr;
+use regex::Regex;
+#[cfg(feature = "rustc-serialize")]
use rustc_serialize::{Decodable, Decoder, Encodable, Encoder};
#[cfg(feature = "serde")]
use serde::{de, Deserialize, Deserializer, Serialize, Serializer};
@@ -64,29 +67,27 @@
#[derive(PartialEq, Eq, Copy, Clone, Debug, Ord, PartialOrd, Hash)]
/// Parsing errors
pub enum ParseError {
- /// Length is incorrect (should be 14 or 17)
+ /// Length is incorrect (should be 11 to 17)
InvalidLength(usize),
- /// Character not [0-9a-fA-F]|'x'|'-'|':'|'.'
- InvalidCharacter(char, usize),
+ /// The input string is invalid, usize bytes were found, and we put up to 6 bytes into Eui48
+ InvalidByteCount(usize, Eui48),
}
impl MacAddress {
/// Create a new MacAddress from `[u8; 6]`.
- pub fn new(eui: Eui48) -> MacAddress {
- MacAddress { eui: eui }
+ pub const fn new(eui: Eui48) -> MacAddress {
+ MacAddress { eui }
}
/// Create a new MacAddress from a byte slice.
///
/// Returns an error (without any description) if the slice doesn't have the proper length.
- pub fn from_bytes(bytes: &[u8]) -> Result<Self, ()> {
+ pub fn from_bytes(bytes: &[u8]) -> Result<Self, ParseError> {
if bytes.len() != EUI48LEN {
- return Err(());
+ return Err(ParseError::InvalidLength(bytes.len()));
}
let mut input: [u8; EUI48LEN] = Default::default();
- for i in 0..EUI48LEN {
- input[i] = bytes[i];
- }
+ input[..EUI48LEN].clone_from_slice(&bytes[..EUI48LEN]);
Ok(Self::new(input))
}
@@ -177,10 +178,10 @@
)
}
- /// Returns a String representation in the IPv6 link local format 'ff80::0000:00ff:fe00:0000'
+ /// Returns a String representation in the IPv6 link local format 'fe80::0000:00ff:fe00:0000'
pub fn to_link_local(&self) -> String {
format!(
- "ff80::{:02x}{:02x}:{:02x}ff:fe{:02x}:{:02x}{:02x}",
+ "fe80::{:02x}{:02x}:{:02x}ff:fe{:02x}:{:02x}{:02x}",
(self.eui[0] ^ 0x02),
self.eui[1],
self.eui[2],
@@ -202,62 +203,35 @@
/// Parses a String representation from any format supported
pub fn parse_str(s: &str) -> Result<MacAddress, ParseError> {
- let mut offset = 0; // Offset into the u8 Eui48 vector
- let mut hn: bool = false; // Have we seen the high nibble yet?
+ let re = Regex::new("(0x)?([0-9a-fA-F]{1,2})[:.-]?").unwrap();
let mut eui: Eui48 = [0; EUI48LEN];
match s.len() {
- 14 | 17 => {} // The formats are all 12 characters with 2 or 5 delims
- _ => return Err(ParseError::InvalidLength(s.len())),
- }
-
- for (idx, c) in s.chars().enumerate() {
- if offset >= EUI48LEN {
- // We shouln't still be parsing
+ 11..=17 => {}
+ _ => {
return Err(ParseError::InvalidLength(s.len()));
}
+ }
- match c {
- '0'...'9' | 'a'...'f' | 'A'...'F' => {
- match hn {
- false => {
- // We will match '0' and run this even if the format is 0x
- hn = true; // Parsed the high nibble
- eui[offset] = (c.to_digit(16).unwrap() as u8) << 4;
- }
- true => {
- hn = false; // Parsed the low nibble
- eui[offset] += c.to_digit(16).unwrap() as u8;
- offset += 1;
- }
- }
- }
- '-' | ':' | '.' => {}
- 'x' | 'X' => {
- match idx {
- 1 => {
- // If idx = 1, we are possibly parsing 0x1234567890ab format
- // Reset the offset to zero to ignore the first two characters
- offset = 0;
- hn = false;
- }
- _ => return Err(ParseError::InvalidCharacter(c, idx)),
- }
- }
- _ => return Err(ParseError::InvalidCharacter(c, idx)),
+ let mut i = 0;
+ for caps in re.captures_iter(s) {
+ // Fill the array and keep counting for InvalidByteCount
+ if i < EUI48LEN {
+ let matched_byte = caps.get(2).unwrap().as_str();
+ eui[i] = u8::from_str_radix(matched_byte, 16).unwrap();
}
+ i += 1;
}
- if offset == EUI48LEN {
- // A correctly parsed value is exactly 6 u8s
- Ok(MacAddress::new(eui))
- } else {
- Err(ParseError::InvalidLength(s.len())) // Something slipped through
+ if i != EUI48LEN {
+ return Err(ParseError::InvalidByteCount(i, eui));
}
+
+ Ok(MacAddress::new(eui))
}
/// Return the internal structure as a slice of bytes
- pub fn as_bytes<'a>(&'a self) -> &'a [u8] {
+ pub fn as_bytes(&self) -> &[u8] {
&self.eui
}
@@ -303,7 +277,7 @@
}
impl fmt::Display for MacAddress {
- /// Display format is canonical format (00-00-00-00-00-00)
+ /// Display format is canonical format (00-00-00-00-00-00) by default
fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
let disp_fmt = MacAddress::get_display_format();
write!(f, "{}", self.to_string(disp_fmt))
@@ -316,12 +290,15 @@
match *self {
ParseError::InvalidLength(found) => write!(
f,
- "Invalid length; expecting 14 or 17 chars, found {}",
+ "Invalid length; expecting 11 to 17 chars, found {}",
found
),
- ParseError::InvalidCharacter(found, pos) => {
- write!(f, "Invalid character; found `{}` at offset {}", found, pos)
- }
+ ParseError::InvalidByteCount(found, eui) => write!(
+ f,
+ "Invalid byte count; Matched `{}` bytes ({:?})",
+ found,
+ &eui[..found]
+ ),
}
}
}
@@ -333,13 +310,16 @@
}
}
+#[cfg(feature = "rustc-serialize")]
impl Encodable for MacAddress {
- /// Encode a MacAddress as canonical form
+ /// Encode a MacAddress using the default format
fn encode<E: Encoder>(&self, e: &mut E) -> Result<(), E::Error> {
- e.emit_str(&self.to_canonical())
+ let disp_fmt = MacAddress::get_display_format();
+ e.emit_str(&self.to_string(disp_fmt))
}
}
+#[cfg(feature = "rustc-serialize")]
impl Decodable for MacAddress {
/// Decode a MacAddress from a string in canonical form
fn decode<D: Decoder>(d: &mut D) -> Result<MacAddress, D::Error> {
@@ -348,15 +328,24 @@
}
}
-#[cfg(feature = "serde")]
+#[cfg(all(feature = "serde", not(feature = "serde_bytes")))]
impl Serialize for MacAddress {
- /// Serialize a MacAddress as canonical form using the serde crate
+ /// Serialize a MacAddress in the default format using the serde crate
fn serialize<S: Serializer>(&self, serializer: S) -> Result<S::Ok, S::Error> {
- serializer.serialize_str(&self.to_canonical())
+ let disp_fmt = MacAddress::get_display_format();
+ serializer.serialize_str(&self.to_string(disp_fmt))
}
}
-#[cfg(feature = "serde")]
+#[cfg(feature = "serde_bytes")]
+impl Serialize for MacAddress {
+ /// Serialize a MacAddress as raw bytes using the serde crate
+ fn serialize<S: Serializer>(&self, serializer: S) -> Result<S::Ok, S::Error> {
+ serializer.serialize_bytes(self.as_bytes())
+ }
+}
+
+#[cfg(all(feature = "serde", not(feature = "serde_bytes")))]
impl<'de> Deserialize<'de> for MacAddress {
/// Deserialize a MacAddress from canonical form using the serde crate
fn deserialize<D: Deserializer<'de>>(deserializer: D) -> Result<Self, D::Error> {
@@ -364,25 +353,38 @@
impl<'de> de::Visitor<'de> for MacAddressVisitor {
type Value = MacAddress;
- fn visit_str<E: de::Error>(self, value: &str) -> Result<MacAddress, E> {
- value.parse().map_err(|err| E::custom(&format!("{}", err)))
- }
-
- fn visit_bytes<E: de::Error>(self, value: &[u8]) -> Result<MacAddress, E> {
- MacAddress::from_bytes(value).map_err(|_| E::invalid_length(value.len(), &self))
- }
-
fn expecting(&self, formatter: &mut fmt::Formatter) -> fmt::Result {
- write!(
- formatter,
- "either a string representation of a MAC address or 6-element byte array"
- )
+ write!(formatter, "a string representation of a MAC address")
+ }
+
+ fn visit_str<E: de::Error>(self, value: &str) -> Result<Self::Value, E> {
+ value.parse().map_err(|err| E::custom(&format!("{}", err)))
}
}
deserializer.deserialize_str(MacAddressVisitor)
}
}
+#[cfg(feature = "serde_bytes")]
+impl<'de> Deserialize<'de> for MacAddress {
+ /// Deserialize a MacAddress from raw bytes using the serde crate
+ fn deserialize<D: Deserializer<'de>>(deserializer: D) -> Result<Self, D::Error> {
+ struct MacAddressVisitor;
+ impl<'de> de::Visitor<'de> for MacAddressVisitor {
+ type Value = MacAddress;
+
+ fn expecting(&self, formatter: &mut fmt::Formatter) -> fmt::Result {
+ write!(formatter, "6-element byte array")
+ }
+
+ fn visit_bytes<E: de::Error>(self, value: &[u8]) -> Result<Self::Value, E> {
+ MacAddress::from_bytes(value).map_err(|_| E::invalid_length(value.len(), &self))
+ }
+ }
+ deserializer.deserialize_bytes(MacAddressVisitor)
+ }
+}
+
// ************** TESTS BEGIN HERE ***************
#[cfg(test)]
mod tests {
@@ -532,7 +534,7 @@
fn test_to_link_local() {
let eui: Eui48 = [0x12, 0x34, 0x56, 0xAB, 0xCD, 0xEF];
let mac = MacAddress::new(eui);
- assert_eq!("ff80::1034:56ff:feab:cdef", mac.to_link_local());
+ assert_eq!("fe80::1034:56ff:feab:cdef", mac.to_link_local());
}
#[test]
@@ -585,60 +587,68 @@
.unwrap()
.to_canonical()
);
+ assert_eq!(
+ "12-34-56-78-90-0a",
+ MacAddress::parse_str("0x1234567890A")
+ .unwrap()
+ .to_canonical()
+ );
+ assert_eq!(
+ "12-34-56-ab-cd-ef",
+ MacAddress::parse_str("123456ABCDEF")
+ .unwrap()
+ .to_canonical()
+ );
+ assert_eq!(
+ "00-00-00-00-00-00",
+ MacAddress::parse_str("!0x00000000000")
+ .unwrap()
+ .to_canonical()
+ );
+ assert_eq!(
+ "00-00-00-00-00-00",
+ MacAddress::parse_str("0x00000000000!")
+ .unwrap()
+ .to_canonical()
+ );
// Test error parsing
assert_eq!(MacAddress::parse_str(""), Err(InvalidLength(0)));
assert_eq!(MacAddress::parse_str("0"), Err(InvalidLength(1)));
assert_eq!(
- MacAddress::parse_str("123456ABCDEF"),
- Err(InvalidLength(12))
- );
- assert_eq!(
MacAddress::parse_str("1234567890ABCD"),
- Err(InvalidLength(14))
+ Err(InvalidByteCount(7, [0x12, 0x34, 0x56, 0x78, 0x90, 0xAB]))
);
assert_eq!(
MacAddress::parse_str("1234567890ABCDEF"),
- Err(InvalidLength(16))
+ Err(InvalidByteCount(8, [0x12, 0x34, 0x56, 0x78, 0x90, 0xAB]))
);
assert_eq!(
MacAddress::parse_str("01234567890ABCDEF"),
- Err(InvalidLength(17))
- );
- assert_eq!(
- MacAddress::parse_str("0x1234567890A"),
- Err(InvalidLength(13))
+ Err(InvalidByteCount(9, [0x01, 0x23, 0x45, 0x67, 0x89, 0x0A]))
);
assert_eq!(
MacAddress::parse_str("0x1234567890ABCDE"),
- Err(InvalidLength(17))
+ Err(InvalidByteCount(8, [0x12, 0x34, 0x56, 0x78, 0x90, 0xAB]))
);
assert_eq!(
- MacAddress::parse_str("0x00:00:00:00:"),
- Err(InvalidLength(14))
+ MacAddress::parse_str("0x00:01:02:03:"),
+ Err(InvalidByteCount(4, [0, 1, 2, 3, 0, 0]))
);
assert_eq!(
- MacAddress::parse_str("0x00:00:00:00:00:"),
- Err(InvalidLength(17))
+ MacAddress::parse_str("0x00:01:02:03:04:"),
+ Err(InvalidByteCount(5, [0, 1, 2, 3, 4, 0]))
);
assert_eq!(
MacAddress::parse_str("::::::::::::::"),
- Err(InvalidLength(14))
+ Err(InvalidByteCount(0, [0, 0, 0, 0, 0, 0]))
);
assert_eq!(
MacAddress::parse_str(":::::::::::::::::"),
- Err(InvalidLength(17))
+ Err(InvalidByteCount(0, [0, 0, 0, 0, 0, 0]))
);
assert_eq!(
MacAddress::parse_str("0x0x0x0x0x0x0x"),
- Err(InvalidCharacter('x', 3))
- );
- assert_eq!(
- MacAddress::parse_str("!0x00000000000"),
- Err(InvalidCharacter('!', 0))
- );
- assert_eq!(
- MacAddress::parse_str("0x00000000000!"),
- Err(InvalidCharacter('!', 13))
+ Err(InvalidByteCount(4, [0, 0, 0, 0, 0, 0]))
);
}
@@ -655,20 +665,20 @@
fn test_compare() {
let m1 = MacAddress::nil();
let m2 = MacAddress::broadcast();
- assert!(m1 == m1);
- assert!(m2 == m2);
- assert!(m1 != m2);
- assert!(m2 != m1);
+ assert_eq!(m1, m1);
+ assert_eq!(m2, m2);
+ assert_ne!(m1, m2);
+ assert_ne!(m2, m1);
}
#[test]
fn test_clone() {
let m1 = MacAddress::parse_str("12:34:56:AB:CD:EF").unwrap();
- let m2 = m1.clone();
- assert!(m1 == m1);
- assert!(m2 == m2);
- assert!(m1 == m2);
- assert!(m2 == m1);
+ let m2 = m1;
+ assert_eq!(m1, m1);
+ assert_eq!(m2, m2);
+ assert_eq!(m1, m2);
+ assert_eq!(m2, m1);
}
#[test]
@@ -676,16 +686,27 @@
use rustc_serialize::json;
let mac = MacAddress::parse_str("12:34:56:AB:CD:EF").unwrap();
- assert_eq!("\"12-34-56-ab-cd-ef\"", json::encode(&mac).unwrap());
+ // Format returned is base on compile time of feature(disp_hexstring)
+ if cfg!(feature = "disp_hexstring") {
+ assert_eq!("\"12:34:56:ab:cd:ef\"", json::encode(&mac).unwrap());
+ } else {
+ assert_eq!("\"12-34-56-ab-cd-ef\"", json::encode(&mac).unwrap());
+ }
}
#[test]
fn test_deserialize() {
use rustc_serialize::json;
- let d = "\"12-34-56-AB-CD-EF\"";
let mac = MacAddress::parse_str("12:34:56:AB:CD:EF").unwrap();
- assert_eq!(mac, json::decode(&d).unwrap());
+
+ if cfg!(feature = "disp_hexstring") {
+ let d = "\"12:34:56:AB:CD:EF\"";
+ assert_eq!(mac, json::decode(&d).unwrap());
+ } else {
+ let d = "\"12-34-56-AB-CD-EF\"";
+ assert_eq!(mac, json::decode(&d).unwrap());
+ }
}
#[test]
@@ -709,7 +730,7 @@
#[test]
fn test_fmt() {
- let mac = MacAddress::parse_str("12:34:56:AB:CD:EF").unwrap();
+ let mac = MacAddress::parse_str("0x123456ABCDEF").unwrap();
match MacAddress::get_display_format() {
MacAddressFormat::HexString => {
assert_eq!("12:34:56:ab:cd:ef".to_owned(), format!("{}", mac))
@@ -721,12 +742,12 @@
#[test]
fn test_fmt_parse_errors() {
assert_eq!(
- "Err(InvalidLength(12))".to_owned(),
- format!("{:?}", MacAddress::parse_str("123456ABCDEF"))
+ "Err(InvalidByteCount(7, [18, 52, 86, 171, 205, 239]))".to_owned(),
+ format!("{:?}", MacAddress::parse_str("123456ABCDEF1"))
);
assert_eq!(
- "Err(InvalidCharacter(\'#\', 2))".to_owned(),
- format!("{:?}", MacAddress::parse_str("12#34#56#AB#CD#EF"))
+ "Err(InvalidLength(19))",
+ format!("{:?}", MacAddress::parse_str("12##45#67#89#AB#C#D"))
);
}
@@ -736,7 +757,11 @@
use serde_json;
let serialized =
serde_json::to_string(&MacAddress::parse_str("12:34:56:AB:CD:EF").unwrap()).unwrap();
- assert_eq!("\"12-34-56-ab-cd-ef\"", serialized);
+ if cfg!(feature = "disp_hexstring") {
+ assert_eq!("\"12:34:56:ab:cd:ef\"", serialized);
+ } else {
+ assert_eq!("\"12-34-56-ab-cd-ef\"", serialized);
+ }
}
#[test]
@@ -749,6 +774,24 @@
}
#[test]
+ #[should_panic(expected = "Invalid length; expecting 11 to 17 chars, found 2")]
+ #[cfg(feature = "serde_json")]
+ fn test_serde_json_deserialize_panic() {
+ let _should_panic: MacAddress = serde_json::from_str("\"12\"").unwrap();
+ }
+
+ #[test]
+ #[cfg(feature = "serde_bytes")]
+ fn test_serde_bytes_serialization_roundtrip() {
+ use bincode;
+ let mac = MacAddress::parse_str("12:34:56:AB:CD:EF").unwrap();
+ let mut buffer = Vec::new();
+ bincode::serialize_into(&mut buffer, &mac).unwrap();
+ let deserialized: MacAddress = bincode::deserialize_from(&*buffer).unwrap();
+ assert_eq!(deserialized, mac);
+ }
+
+ #[test]
fn test_macaddressformat_derive() {
assert_eq!(MacAddressFormat::HexString, MacAddressFormat::HexString);
assert_ne!(MacAddressFormat::HexString, MacAddressFormat::Canonical);
@@ -756,18 +799,13 @@
#[test]
fn test_parseerror_fmt() {
- use std::error::Error;
assert_eq!(
- "Invalid length; expecting 14 or 17 chars, found 2".to_owned(),
+ "Invalid length; expecting 11 to 17 chars, found 2".to_owned(),
format!("{}", ParseError::InvalidLength(2))
);
assert_eq!(
- "Invalid character; found `@` at offset 2".to_owned(),
- format!("{}", ParseError::InvalidCharacter('@', 2))
- );
- assert_eq!(
- "MacAddress parse error".to_owned(),
- format!("{}", ParseError::InvalidLength(2).description())
+ "Invalid length; expecting 11 to 17 chars, found 2".to_owned(),
+ ParseError::InvalidLength(2).to_string()
);
}
diff --git a/third_party/rust_crates/vendor/rustc-serialize/.cargo-checksum.json b/third_party/rust_crates/vendor/rustc-serialize/.cargo-checksum.json
deleted file mode 100644
index 5c6ba3c..0000000
--- a/third_party/rust_crates/vendor/rustc-serialize/.cargo-checksum.json
+++ /dev/null
@@ -1 +0,0 @@
-{"files":{"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
diff --git a/third_party/rust_crates/vendor/rustc-serialize/Cargo.toml b/third_party/rust_crates/vendor/rustc-serialize/Cargo.toml
deleted file mode 100644
index 2f44e0c..0000000
--- a/third_party/rust_crates/vendor/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"
diff --git a/third_party/rust_crates/vendor/rustc-serialize/LICENSE-APACHE b/third_party/rust_crates/vendor/rustc-serialize/LICENSE-APACHE
deleted file mode 100644
index 16fe87b..0000000
--- a/third_party/rust_crates/vendor/rustc-serialize/LICENSE-APACHE
+++ /dev/null
@@ -1,201 +0,0 @@
- Apache License
- Version 2.0, January 2004
- http://www.apache.org/licenses/
-
-TERMS AND CONDITIONS FOR USE, REPRODUCTION, AND DISTRIBUTION
-
-1. Definitions.
-
- "License" shall mean the terms and conditions for use, reproduction,
- and distribution as defined by Sections 1 through 9 of this document.
-
- "Licensor" shall mean the copyright owner or entity authorized by
- the copyright owner that is granting the License.
-
- "Legal Entity" shall mean the union of the acting entity and all
- other entities that control, are controlled by, or are under common
- control with that entity. For the purposes of this definition,
- "control" means (i) the power, direct or indirect, to cause the
- direction or management of such entity, whether by contract or
- otherwise, or (ii) ownership of fifty percent (50%) or more of the
- outstanding shares, or (iii) beneficial ownership of such entity.
-
- "You" (or "Your") shall mean an individual or Legal Entity
- exercising permissions granted by this License.
-
- "Source" form shall mean the preferred form for making modifications,
- including but not limited to software source code, documentation
- source, and configuration files.
-
- "Object" form shall mean any form resulting from mechanical
- transformation or translation of a Source form, including but
- not limited to compiled object code, generated documentation,
- and conversions to other media types.
-
- "Work" shall mean the work of authorship, whether in Source or
- Object form, made available under the License, as indicated by a
- copyright notice that is included in or attached to the work
- (an example is provided in the Appendix below).
-
- "Derivative Works" shall mean any work, whether in Source or Object
- form, that is based on (or derived from) the Work and for which the
- editorial revisions, annotations, elaborations, or other modifications
- represent, as a whole, an original work of authorship. For the purposes
- of this License, Derivative Works shall not include works that remain
- separable from, or merely link (or bind by name) to the interfaces of,
- the Work and Derivative Works thereof.
-
- "Contribution" shall mean any work of authorship, including
- the original version of the Work and any modifications or additions
- to that Work or Derivative Works thereof, that is intentionally
- submitted to Licensor for inclusion in the Work by the copyright owner
- or by an individual or Legal Entity authorized to submit on behalf of
- the copyright owner. For the purposes of this definition, "submitted"
- means any form of electronic, verbal, or written communication sent
- to the Licensor or its representatives, including but not limited to
- communication on electronic mailing lists, source code control systems,
- and issue tracking systems that are managed by, or on behalf of, the
- Licensor for the purpose of discussing and improving the Work, but
- excluding communication that is conspicuously marked or otherwise
- designated in writing by the copyright owner as "Not a Contribution."
-
- "Contributor" shall mean Licensor and any individual or Legal Entity
- on behalf of whom a Contribution has been received by Licensor and
- subsequently incorporated within the Work.
-
-2. Grant of Copyright License. Subject to the terms and conditions of
- this License, each Contributor hereby grants to You a perpetual,
- worldwide, non-exclusive, no-charge, royalty-free, irrevocable
- copyright license to reproduce, prepare Derivative Works of,
- publicly display, publicly perform, sublicense, and distribute the
- Work and such Derivative Works in Source or Object form.
-
-3. Grant of Patent License. Subject to the terms and conditions of
- this License, each Contributor hereby grants to You a perpetual,
- worldwide, non-exclusive, no-charge, royalty-free, irrevocable
- (except as stated in this section) patent license to make, have made,
- use, offer to sell, sell, import, and otherwise transfer the Work,
- where such license applies only to those patent claims licensable
- by such Contributor that are necessarily infringed by their
- Contribution(s) alone or by combination of their Contribution(s)
- with the Work to which such Contribution(s) was submitted. If You
- institute patent litigation against any entity (including a
- cross-claim or counterclaim in a lawsuit) alleging that the Work
- or a Contribution incorporated within the Work constitutes direct
- or contributory patent infringement, then any patent licenses
- granted to You under this License for that Work shall terminate
- as of the date such litigation is filed.
-
-4. Redistribution. You may reproduce and distribute copies of the
- Work or Derivative Works thereof in any medium, with or without
- modifications, and in Source or Object form, provided that You
- meet the following conditions:
-
- (a) You must give any other recipients of the Work or
- Derivative Works a copy of this License; and
-
- (b) You must cause any modified files to carry prominent notices
- stating that You changed the files; and
-
- (c) You must retain, in the Source form of any Derivative Works
- that You distribute, all copyright, patent, trademark, and
- attribution notices from the Source form of the Work,
- excluding those notices that do not pertain to any part of
- the Derivative Works; and
-
- (d) If the Work includes a "NOTICE" text file as part of its
- distribution, then any Derivative Works that You distribute must
- include a readable copy of the attribution notices contained
- within such NOTICE file, excluding those notices that do not
- pertain to any part of the Derivative Works, in at least one
- of the following places: within a NOTICE text file distributed
- as part of the Derivative Works; within the Source form or
- documentation, if provided along with the Derivative Works; or,
- within a display generated by the Derivative Works, if and
- wherever such third-party notices normally appear. The contents
- of the NOTICE file are for informational purposes only and
- do not modify the License. You may add Your own attribution
- notices within Derivative Works that You distribute, alongside
- or as an addendum to the NOTICE text from the Work, provided
- that such additional attribution notices cannot be construed
- as modifying the License.
-
- You may add Your own copyright statement to Your modifications and
- may provide additional or different license terms and conditions
- for use, reproduction, or distribution of Your modifications, or
- for any such Derivative Works as a whole, provided Your use,
- reproduction, and distribution of the Work otherwise complies with
- the conditions stated in this License.
-
-5. Submission of Contributions. Unless You explicitly state otherwise,
- any Contribution intentionally submitted for inclusion in the Work
- by You to the Licensor shall be under the terms and conditions of
- this License, without any additional terms or conditions.
- Notwithstanding the above, nothing herein shall supersede or modify
- the terms of any separate license agreement you may have executed
- with Licensor regarding such Contributions.
-
-6. Trademarks. This License does not grant permission to use the trade
- names, trademarks, service marks, or product names of the Licensor,
- except as required for reasonable and customary use in describing the
- origin of the Work and reproducing the content of the NOTICE file.
-
-7. Disclaimer of Warranty. Unless required by applicable law or
- agreed to in writing, Licensor provides the Work (and each
- Contributor provides its Contributions) on an "AS IS" BASIS,
- WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or
- implied, including, without limitation, any warranties or conditions
- of TITLE, NON-INFRINGEMENT, MERCHANTABILITY, or FITNESS FOR A
- PARTICULAR PURPOSE. You are solely responsible for determining the
- appropriateness of using or redistributing the Work and assume any
- risks associated with Your exercise of permissions under this License.
-
-8. Limitation of Liability. In no event and under no legal theory,
- whether in tort (including negligence), contract, or otherwise,
- unless required by applicable law (such as deliberate and grossly
- negligent acts) or agreed to in writing, shall any Contributor be
- liable to You for damages, including any direct, indirect, special,
- incidental, or consequential damages of any character arising as a
- result of this License or out of the use or inability to use the
- Work (including but not limited to damages for loss of goodwill,
- work stoppage, computer failure or malfunction, or any and all
- other commercial damages or losses), even if such Contributor
- has been advised of the possibility of such damages.
-
-9. Accepting Warranty or Additional Liability. While redistributing
- the Work or Derivative Works thereof, You may choose to offer,
- and charge a fee for, acceptance of support, warranty, indemnity,
- or other liability obligations and/or rights consistent with this
- License. However, in accepting such obligations, You may act only
- on Your own behalf and on Your sole responsibility, not on behalf
- of any other Contributor, and only if You agree to indemnify,
- defend, and hold each Contributor harmless for any liability
- incurred by, or claims asserted against, such Contributor by reason
- of your accepting any such warranty or additional liability.
-
-END OF TERMS AND CONDITIONS
-
-APPENDIX: How to apply the Apache License to your work.
-
- To apply the Apache License to your work, attach the following
- boilerplate notice, with the fields enclosed by brackets "[]"
- replaced with your own identifying information. (Don't include
- the brackets!) The text should be enclosed in the appropriate
- comment syntax for the file format. We also recommend that a
- file or class name and description of purpose be included on the
- same "printed page" as the copyright notice for easier
- identification within third-party archives.
-
-Copyright [yyyy] [name of copyright owner]
-
-Licensed under the Apache License, Version 2.0 (the "License");
-you may not use this file except in compliance with the License.
-You may obtain a copy of the License at
-
- http://www.apache.org/licenses/LICENSE-2.0
-
-Unless required by applicable law or agreed to in writing, software
-distributed under the License is distributed on an "AS IS" BASIS,
-WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
-See the License for the specific language governing permissions and
-limitations under the License.
diff --git a/third_party/rust_crates/vendor/rustc-serialize/LICENSE-MIT b/third_party/rust_crates/vendor/rustc-serialize/LICENSE-MIT
deleted file mode 100644
index 39d4bdb5..0000000
--- a/third_party/rust_crates/vendor/rustc-serialize/LICENSE-MIT
+++ /dev/null
@@ -1,25 +0,0 @@
-Copyright (c) 2014 The Rust Project Developers
-
-Permission is hereby granted, free of charge, to any
-person obtaining a copy of this software and associated
-documentation files (the "Software"), to deal in the
-Software without restriction, including without
-limitation the rights to use, copy, modify, merge,
-publish, distribute, sublicense, and/or sell copies of
-the Software, and to permit persons to whom the Software
-is furnished to do so, subject to the following
-conditions:
-
-The above copyright notice and this permission notice
-shall be included in all copies or substantial portions
-of the Software.
-
-THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF
-ANY KIND, EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED
-TO THE WARRANTIES OF MERCHANTABILITY, FITNESS FOR A
-PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT
-SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY
-CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION
-OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR
-IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER
-DEALINGS IN THE SOFTWARE.
diff --git a/third_party/rust_crates/vendor/rustc-serialize/OWNERS b/third_party/rust_crates/vendor/rustc-serialize/OWNERS
deleted file mode 100644
index e21639b..0000000
--- a/third_party/rust_crates/vendor/rustc-serialize/OWNERS
+++ /dev/null
@@ -1,6 +0,0 @@
-# AUTOGENERATED FROM DEPENDENT BUILD TARGETS.
-# TO MAKE CHANGES HERE, UPDATE //third_party/rust_crates/owners.toml.
-# DOCS: https://fuchsia.dev/fuchsia-src/development/languages/rust/third_party#owners-files
-
-include /third_party/rust_crates/mirrors/rust-crypto/OWNERS
-include /third_party/rust_crates/vendor/eui48/OWNERS
diff --git a/third_party/rust_crates/vendor/rustc-serialize/README.md b/third_party/rust_crates/vendor/rustc-serialize/README.md
deleted file mode 100644
index f680842..0000000
--- a/third_party/rust_crates/vendor/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;
-```
diff --git a/third_party/rust_crates/vendor/rustc-serialize/appveyor.yml b/third_party/rust_crates/vendor/rustc-serialize/appveyor.yml
deleted file mode 100644
index 6a1b8dc..0000000
--- a/third_party/rust_crates/vendor/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
diff --git a/third_party/rust_crates/vendor/rustc-serialize/benches/base64.rs b/third_party/rust_crates/vendor/rustc-serialize/benches/base64.rs
deleted file mode 100644
index 6a6565b..0000000
--- a/third_party/rust_crates/vendor/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;
-}
diff --git a/third_party/rust_crates/vendor/rustc-serialize/benches/hex.rs b/third_party/rust_crates/vendor/rustc-serialize/benches/hex.rs
deleted file mode 100644
index 97a7735..0000000
--- a/third_party/rust_crates/vendor/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;
-}
diff --git a/third_party/rust_crates/vendor/rustc-serialize/benches/json.rs b/third_party/rust_crates/vendor/rustc-serialize/benches/json.rs
deleted file mode 100644
index 20768e1..0000000
--- a/third_party/rust_crates/vendor/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); });
-}
diff --git a/third_party/rust_crates/vendor/rustc-serialize/src/base64.rs b/third_party/rust_crates/vendor/rustc-serialize/src/base64.rs
deleted file mode 100644
index 3c346b8..0000000
--- a/third_party/rust_crates/vendor/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);
- }
- }
-}
diff --git a/third_party/rust_crates/vendor/rustc-serialize/src/collection_impls.rs b/third_party/rust_crates/vendor/rustc-serialize/src/collection_impls.rs
deleted file mode 100644
index f8074c9..0000000
--- a/third_party/rust_crates/vendor/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)
- })
- }
-}
diff --git a/third_party/rust_crates/vendor/rustc-serialize/src/hex.rs b/third_party/rust_crates/vendor/rustc-serialize/src/hex.rs
deleted file mode 100644
index 3c7df19..0000000
--- a/third_party/rust_crates/vendor/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);
- }
- }
-}
diff --git a/third_party/rust_crates/vendor/rustc-serialize/src/json.rs b/third_party/rust_crates/vendor/rustc-serialize/src/json.rs
deleted file mode 100644
index e478fe8..0000000
--- a/third_party/rust_crates/vendor/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)),
- _ => ()
- };
- }
-}
diff --git a/third_party/rust_crates/vendor/rustc-serialize/src/lib.rs b/third_party/rust_crates/vendor/rustc-serialize/src/lib.rs
deleted file mode 100644
index 8b0fb22..0000000
--- a/third_party/rust_crates/vendor/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::*;
-}
diff --git a/third_party/rust_crates/vendor/rustc-serialize/src/serialize.rs b/third_party/rust_crates/vendor/rustc-serialize/src/serialize.rs
deleted file mode 100644
index 296f3d4..0000000
--- a/third_party/rust_crates/vendor/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());
-}
