From 2e87e8b61df249890c43fb7cfef027a6283a5af0 Mon Sep 17 00:00:00 2001 From: Kartikaya Gupta Date: Fri, 13 Oct 2017 12:57:56 -0400 Subject: [PATCH] Bug 1407213 - Update Cargo lockfiles and re-vendor rust libraries. r=jrmuizel MozReview-Commit-ID: Jz76sncivdF --HG-- rename : third_party/rust/bincode/logo.png => third_party/rust/bincode-0.8.0/logo.png extra : rebase_source : bc3ba0e5ce54908def30fed2ab78487a1a9b6b93 --- .../rust/bincode-0.8.0/.cargo-checksum.json | 1 + third_party/rust/bincode-0.8.0/.cargo-ok | 0 third_party/rust/bincode-0.8.0/.travis.yml | 5 + third_party/rust/bincode-0.8.0/Cargo.toml | 20 + third_party/rust/bincode-0.8.0/LICENSE.md | 21 + third_party/rust/bincode-0.8.0/changelist.org | 27 + .../rust/bincode-0.8.0/examples/basic.rs | 27 + third_party/rust/bincode-0.8.0/logo.png | Bin 0 -> 258333 bytes third_party/rust/bincode-0.8.0/readme.dev.md | 39 + third_party/rust/bincode-0.8.0/readme.md | 73 ++ third_party/rust/bincode-0.8.0/src/de/mod.rs | 416 +++++++++++ third_party/rust/bincode-0.8.0/src/de/read.rs | 151 ++++ .../rust/bincode-0.8.0/src/internal.rs | 240 ++++++ third_party/rust/bincode-0.8.0/src/lib.rs | 167 +++++ third_party/rust/bincode-0.8.0/src/ser/mod.rs | 687 ++++++++++++++++++ third_party/rust/bincode-0.8.0/tests/test.rs | 419 +++++++++++ third_party/rust/bincode/.cargo-checksum.json | 2 +- third_party/rust/bincode/Cargo.toml | 37 +- third_party/rust/bincode/examples/basic.rs | 8 +- third_party/rust/bincode/readme.md | 15 +- third_party/rust/bincode/src/de/mod.rs | 26 +- third_party/rust/bincode/src/de/read.rs | 42 +- third_party/rust/bincode/src/internal.rs | 95 +-- third_party/rust/bincode/src/lib.rs | 26 +- third_party/rust/bincode/tests/test.rs | 29 +- .../rust/gamma-lut/.cargo-checksum.json | 2 +- third_party/rust/gamma-lut/Cargo.toml | 24 +- third_party/rust/gamma-lut/src/lib.rs | 12 +- toolkit/library/gtest/rust/Cargo.lock | 20 +- toolkit/library/rust/Cargo.lock | 20 +- 30 files changed, 2504 insertions(+), 147 deletions(-) create mode 100644 third_party/rust/bincode-0.8.0/.cargo-checksum.json create mode 100644 third_party/rust/bincode-0.8.0/.cargo-ok create mode 100644 third_party/rust/bincode-0.8.0/.travis.yml create mode 100644 third_party/rust/bincode-0.8.0/Cargo.toml create mode 100644 third_party/rust/bincode-0.8.0/LICENSE.md create mode 100644 third_party/rust/bincode-0.8.0/changelist.org create mode 100644 third_party/rust/bincode-0.8.0/examples/basic.rs create mode 100644 third_party/rust/bincode-0.8.0/logo.png create mode 100644 third_party/rust/bincode-0.8.0/readme.dev.md create mode 100644 third_party/rust/bincode-0.8.0/readme.md create mode 100644 third_party/rust/bincode-0.8.0/src/de/mod.rs create mode 100644 third_party/rust/bincode-0.8.0/src/de/read.rs create mode 100644 third_party/rust/bincode-0.8.0/src/internal.rs create mode 100644 third_party/rust/bincode-0.8.0/src/lib.rs create mode 100644 third_party/rust/bincode-0.8.0/src/ser/mod.rs create mode 100644 third_party/rust/bincode-0.8.0/tests/test.rs diff --git a/third_party/rust/bincode-0.8.0/.cargo-checksum.json b/third_party/rust/bincode-0.8.0/.cargo-checksum.json new file mode 100644 index 000000000000..0d32e2459106 --- /dev/null +++ b/third_party/rust/bincode-0.8.0/.cargo-checksum.json @@ -0,0 +1 @@ +{"files":{".cargo-ok":"e3b0c44298fc1c149afbf4c8996fb92427ae41e4649b934ca495991b7852b855",".travis.yml":"f705a11b487bf71c41ebd8223cc1f3cbde0dfdfeea96a100af55e06e93397a1b","Cargo.toml":"b3ef32df664d22cfe4526f0022c8789e8976970b9e0982e1dd52f4f811134515","LICENSE.md":"90d7e062634054e6866d3c81e6a2b3058a840e6af733e98e80bdfe1a7dec6912","changelist.org":"936b58455e1c221539b73b5250302dcd96baa04a5d8536199d3351142addad57","examples/basic.rs":"ef6ab76936c8322b9f89fe8308311339c0bf7b413c5f88b5314b0035d49917a3","logo.png":"ebc5305aae938c1f834cf35302faa8be0f1b7b8c3c3beef5cf6b2f68b9628c35","readme.dev.md":"43bad3bcc13a5c057344d3ba7f64bd2b313f8c133d6afa068108df73e8e8facd","readme.md":"ca48b4a712089d792d449ef6e0e399efaf227dbcfcb141540684a16a2763583b","src/de/mod.rs":"8651e00130bd062e2305dcce8b68d777fff9877688e776b239778e18046dddaf","src/de/read.rs":"5abca51c6f0d93cc144914ed30bf2cfd0074ced09a0de8c3983997aaa471562d","src/internal.rs":"d9448e8467caf4cf24703626dab9e0d9420e98419e323ad7e611e4aeab525e4a","src/lib.rs":"998b85e103f8f5480ffeef43bd8430a66c061011055a053377f37dce32bf9088","src/ser/mod.rs":"0eeb467eeb8189fb935e4996cd45d1f292c401f92b00793907bd428f1bde421d","tests/test.rs":"26598b882a691caa5301a569e56e31567bfba5ffeab6f0ca67ebd95bfae679b0"},"package":"e103c8b299b28a9c6990458b7013dc4a8356a9b854c51b9883241f5866fac36e"} \ No newline at end of file diff --git a/third_party/rust/bincode-0.8.0/.cargo-ok b/third_party/rust/bincode-0.8.0/.cargo-ok new file mode 100644 index 000000000000..e69de29bb2d1 diff --git a/third_party/rust/bincode-0.8.0/.travis.yml b/third_party/rust/bincode-0.8.0/.travis.yml new file mode 100644 index 000000000000..35b04d501b6f --- /dev/null +++ b/third_party/rust/bincode-0.8.0/.travis.yml @@ -0,0 +1,5 @@ +language: rust +rust: + - stable + - beta + - nightly diff --git a/third_party/rust/bincode-0.8.0/Cargo.toml b/third_party/rust/bincode-0.8.0/Cargo.toml new file mode 100644 index 000000000000..ddf68cbed21a --- /dev/null +++ b/third_party/rust/bincode-0.8.0/Cargo.toml @@ -0,0 +1,20 @@ +[package] +name = "bincode" +version = "0.8.0" +authors = ["Ty Overby ", "Francesco Mazzoli ", "David Tolnay ", "Daniel Griffen"] + +repository = "https://github.com/TyOverby/bincode" +documentation = "https://docs.rs/bincode" +keywords = ["binary", "encode", "decode", "serialize", "deserialize"] + +license = "MIT" +description = "A binary serialization / deserialization strategy that uses Serde for transforming structs into bytes and vice versa!" + +[dependencies] +byteorder = "1.0.0" +num-traits = "0.1.32" +serde = "1.*.*" + +[dev-dependencies] +serde_bytes = "0.10.*" +serde_derive = "1.*.*" diff --git a/third_party/rust/bincode-0.8.0/LICENSE.md b/third_party/rust/bincode-0.8.0/LICENSE.md new file mode 100644 index 000000000000..26b1f00a2797 --- /dev/null +++ b/third_party/rust/bincode-0.8.0/LICENSE.md @@ -0,0 +1,21 @@ +The MIT License (MIT) + +Copyright (c) 2014 Ty Overby + +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/bincode-0.8.0/changelist.org b/third_party/rust/bincode-0.8.0/changelist.org new file mode 100644 index 000000000000..c8de3176b1f3 --- /dev/null +++ b/third_party/rust/bincode-0.8.0/changelist.org @@ -0,0 +1,27 @@ +* 1.0.0 +** Removed depricated rustc-serialize support + Rustc-serialize was a stopgap until projects like Serde were able to catch up. + With macros stabilization on its way, we are able to switch to serde without any + big user-friendliness issues. Major congratulations to Serde for coming this far! + +** Moved Refbox, Strbox and Slicebox into a "refbox" module + Refbox, Strbox and Slicebox are still an integral piece of bincode, but since + they are mainly used by power-users, this move will make the crate API more organized + and easier for new users to understand. + +** Upgraded to Serde 0.9.* + Serde 0.9.* gives us a better API surface area and allows use of procedural macros for + deriving serialize and deserialize implemenetations. + +** Moved serde functions into global module + Since serde is the only supported serialization mechanism, it makes sense to have these + functions available at the top level. + +** Added the ability to chose your own endian encoding. + This functionality is located in the endian_choice module. + +** Changed SizeLimit to be a trait instead of an enum + Mostly for performance reasons. + +** Removed RefBox / StrBox / SliceBox + Since rustc-serialize support was phased out, you can use `Cow` with serde. diff --git a/third_party/rust/bincode-0.8.0/examples/basic.rs b/third_party/rust/bincode-0.8.0/examples/basic.rs new file mode 100644 index 000000000000..28c8b61bedfc --- /dev/null +++ b/third_party/rust/bincode-0.8.0/examples/basic.rs @@ -0,0 +1,27 @@ +#[macro_use] +extern crate serde_derive; +extern crate bincode; + +use bincode::{serialize, deserialize, Infinite}; + +#[derive(Serialize, Deserialize, PartialEq)] +struct Entity { + x: f32, + y: f32, +} + +#[derive(Serialize, Deserialize, PartialEq)] +struct World(Vec); + +fn main() { + let world = World(vec![Entity { x: 0.0, y: 4.0 }, Entity { x: 10.0, y: 20.5 }]); + + let encoded: Vec = serialize(&world, Infinite).unwrap(); + + // 8 bytes for the length of the vector, 4 bytes per float. + assert_eq!(encoded.len(), 8 + 4 * 4); + + let decoded: World = deserialize(&encoded[..]).unwrap(); + + assert!(world == decoded); +} diff --git a/third_party/rust/bincode-0.8.0/logo.png b/third_party/rust/bincode-0.8.0/logo.png new file mode 100644 index 0000000000000000000000000000000000000000..b2c454d1f2103b1a9279c9c6acc6e6a23bb7b76d GIT binary patch literal 258333 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 + +[![Build Status](https://travis-ci.org/TyOverby/bincode.svg)](https://travis-ci.org/TyOverby/bincode) +[![](http://meritbadge.herokuapp.com/bincode)](https://crates.io/crates/bincode) + +A compact encoder / decoder pair that uses an binary zero-fluff encoding scheme. +The size of the encoded object will be the same or smaller than the size that +the object takes up in memory in a running Rust program. + +In addition to exposing two simple funcitons that encode to Vec and decode +from Vec, binary-encode exposes a Reader/Writer API that makes it work +perfectly with other stream-based apis such as rust files, network streams, +and the [flate2-rs](https://github.com/alexcrichton/flate2-rs) compression +library. + +[Api Documentation](http://tyoverby.github.io/bincode/bincode/) + +## Example + +^code(./examples/basic.rs) + + +## Details + +The encoding (and thus decoding) proceeds unsurprisingly -- primitive +types are encoded according to the underlying `Writer`, tuples and +structs are encoded by encoding their fields one-by-one, and enums are +encoded by first writing out the tag representing the variant and +then the contents. + +However, there are some implementation details to be aware of: + +* `isize`/`usize` are encoded as `i64`/`u64`, for portability. +* enums variants are encoded as a `u32` instead that as a `uint`. + `u32` is enough for all practical uses. +* `str` is encoded as `(u64, &[u8])`, where the `u64` is the number of + bytes contained in the encoded string. diff --git a/third_party/rust/bincode-0.8.0/readme.md b/third_party/rust/bincode-0.8.0/readme.md new file mode 100644 index 000000000000..b37d43016533 --- /dev/null +++ b/third_party/rust/bincode-0.8.0/readme.md @@ -0,0 +1,73 @@ +# Bincode + + + +[![Build Status](https://travis-ci.org/TyOverby/bincode.svg)](https://travis-ci.org/TyOverby/bincode) +[![](http://meritbadge.herokuapp.com/bincode)](https://crates.io/crates/bincode) +[![](https://img.shields.io/badge/license-MIT-blue.svg)](http://opensource.org/licenses/MIT) + +A compact encoder / decoder pair that uses a binary zero-fluff encoding scheme. +The size of the encoded object will be the same or smaller than the size that +the object takes up in memory in a running Rust program. + +In addition to exposing two simple functions that encode to Vec and decode +from Vec, binary-encode exposes a Reader/Writer API that makes it work +perfectly with other stream-based apis such as rust files, network streams, +and the [flate2-rs](https://github.com/alexcrichton/flate2-rs) compression +library. + +## [Api Documentation](http://tyoverby.github.io/bincode/bincode/) + +## Bincode in the wild + +* [google/tarpc](https://github.com/google/tarpc): Bincode is used to serialize and deserialize networked RPC messages. +* [servo/webrender](https://github.com/servo/webrender): Bincode records webrender API calls for record/replay-style graphics debugging. +* [servo/ipc-channel](https://github.com/servo/ipc-channel): Ipc-Channel uses Bincode to send structs between processes using a channel-like API. + +## Example +```rust +#[macro_use] +extern crate serde_derive; +extern crate bincode; + +use bincode::{serialize, deserialize, Infinite}; + +#[derive(Serialize, Deserialize, PartialEq)] +struct Entity { + x: f32, + y: f32, +} + +#[derive(Serialize, Deserialize, PartialEq)] +struct World(Vec); + +fn main() { + let world = World(vec![Entity { x: 0.0, y: 4.0 }, Entity { x: 10.0, y: 20.5 }]); + + let encoded: Vec = serialize(&world, Infinite).unwrap(); + + // 8 bytes for the length of the vector, 4 bytes per float. + assert_eq!(encoded.len(), 8 + 4 * 4); + + let decoded: World = deserialize(&encoded[..]).unwrap(); + + assert!(world == decoded); +} +``` + + +## Details + +The encoding (and thus decoding) proceeds unsurprisingly -- primitive +types are encoded according to the underlying `Writer`, tuples and +structs are encoded by encoding their fields one-by-one, and enums are +encoded by first writing out the tag representing the variant and +then the contents. + +However, there are some implementation details to be aware of: + +* `isize`/`usize` are encoded as `i64`/`u64`, for portability. +* enums variants are encoded as a `u32` instead of a `uint`. + `u32` is enough for all practical uses. +* `str` is encoded as `(u64, &[u8])`, where the `u64` is the number of + bytes contained in the encoded string. diff --git a/third_party/rust/bincode-0.8.0/src/de/mod.rs b/third_party/rust/bincode-0.8.0/src/de/mod.rs new file mode 100644 index 000000000000..b98be7e4df75 --- /dev/null +++ b/third_party/rust/bincode-0.8.0/src/de/mod.rs @@ -0,0 +1,416 @@ +use std::io::Read; +use std::marker::PhantomData; + +use byteorder::{ReadBytesExt, ByteOrder}; +use serde_crate as serde; +use serde_crate::de::IntoDeserializer; +use serde_crate::de::Error as DeError; +use ::SizeLimit; +use super::{Result, Error, ErrorKind}; +use self::read::BincodeRead; + +pub mod read; + +/// A Deserializer that reads bytes from a buffer. +/// +/// This struct should rarely be used. +/// In most cases, prefer the `decode_from` function. +/// +/// The ByteOrder that is chosen will impact the endianness that +/// is used to read integers out of the reader. +/// +/// ```rust,ignore +/// let d = Deserializer::new(&mut some_reader, SizeLimit::new()); +/// serde::Deserialize::deserialize(&mut deserializer); +/// let bytes_read = d.bytes_read(); +/// ``` +pub struct Deserializer { + reader: R, + size_limit: S, + _phantom: PhantomData, +} + +impl<'de, R: BincodeRead<'de>, E: ByteOrder, S: SizeLimit> Deserializer { + /// Creates a new Deserializer with a given `Read`er and a size_limit. + pub fn new(r: R, size_limit: S) -> Deserializer { + Deserializer { + reader: r, + size_limit: size_limit, + _phantom: PhantomData + } + } + + fn read_bytes(&mut self, count: u64) -> Result<()> { + self.size_limit.add(count) + } + + fn read_type(&mut self) -> Result<()> { + use std::mem::size_of; + self.read_bytes(size_of::() as u64) + } + + fn read_vec(&mut self) -> Result> { + let len: usize = try!(serde::Deserialize::deserialize(&mut *self)); + self.read_bytes(len as u64)?; + self.reader.get_byte_buffer(len) + } + + fn read_string(&mut self) -> Result { + String::from_utf8(try!(self.read_vec())).map_err(|err| + ErrorKind::InvalidEncoding{ + desc: "error while decoding utf8 string", + detail: Some(format!("Deserialize error: {}", err)) + }.into()) + } +} + +macro_rules! impl_nums { + ($ty:ty, $dser_method:ident, $visitor_method:ident, $reader_method:ident) => { + #[inline] + fn $dser_method(self, visitor: V) -> Result + where V: serde::de::Visitor<'de>, + { + try!(self.read_type::<$ty>()); + let value = try!(self.reader.$reader_method::()); + visitor.$visitor_method(value) + } + } +} + +impl<'de, 'a, R, S, E> serde::Deserializer<'de> for &'a mut Deserializer +where R: BincodeRead<'de>, S: SizeLimit, E: ByteOrder { + type Error = Error; + + #[inline] + fn deserialize_any(self, _visitor: V) -> Result + where V: serde::de::Visitor<'de>, + { + let message = "bincode does not support Deserializer::deserialize"; + Err(Error::custom(message)) + } + + fn deserialize_bool(self, visitor: V) -> Result + where V: serde::de::Visitor<'de>, + { + let value: u8 = try!(serde::Deserialize::deserialize(self)); + match value { + 1 => visitor.visit_bool(true), + 0 => visitor.visit_bool(false), + value => { + Err(ErrorKind::InvalidEncoding{ + desc: "invalid u8 when decoding bool", + detail: Some(format!("Expected 0 or 1, got {}", value)) + }.into()) + } + } + } + + impl_nums!(u16, deserialize_u16, visit_u16, read_u16); + impl_nums!(u32, deserialize_u32, visit_u32, read_u32); + impl_nums!(u64, deserialize_u64, visit_u64, read_u64); + impl_nums!(i16, deserialize_i16, visit_i16, read_i16); + impl_nums!(i32, deserialize_i32, visit_i32, read_i32); + impl_nums!(i64, deserialize_i64, visit_i64, read_i64); + impl_nums!(f32, deserialize_f32, visit_f32, read_f32); + impl_nums!(f64, deserialize_f64, visit_f64, read_f64); + + + #[inline] + fn deserialize_u8(self, visitor: V) -> Result + where V: serde::de::Visitor<'de>, + { + try!(self.read_type::()); + visitor.visit_u8(try!(self.reader.read_u8())) + } + + #[inline] + fn deserialize_i8(self, visitor: V) -> Result + where V: serde::de::Visitor<'de>, + { + try!(self.read_type::()); + visitor.visit_i8(try!(self.reader.read_i8())) + } + + fn deserialize_unit(self, visitor: V) -> Result + where V: serde::de::Visitor<'de>, + { + visitor.visit_unit() + } + + fn deserialize_char(self, visitor: V) -> Result + where V: serde::de::Visitor<'de>, + { + use std::str; + + let error = || { + ErrorKind::InvalidEncoding{ + desc: "Invalid char encoding", + detail: None, + }.into() + }; + + let mut buf = [0u8; 4]; + + // Look at the first byte to see how many bytes must be read + let _ = try!(self.reader.read_exact(&mut buf[..1])); + let width = utf8_char_width(buf[0]); + if width == 1 { return visitor.visit_char(buf[0] as char) } + if width == 0 { return Err(error())} + + if self.reader.read_exact(&mut buf[1..width]).is_err() { + return Err(error()); + } + + let res = try!(str::from_utf8(&buf[..width]).ok().and_then(|s| s.chars().next()).ok_or(error())); + visitor.visit_char(res) + } + + fn deserialize_str(self, visitor: V) -> Result + where V: serde::de::Visitor<'de>, + { + let len: usize = try!(serde::Deserialize::deserialize(&mut *self)); + try!(self.read_bytes(len as u64)); + self.reader.forward_read_str(len, visitor) + } + + fn deserialize_string(self, visitor: V) -> Result + where V: serde::de::Visitor<'de>, + { + visitor.visit_string(try!(self.read_string())) + } + + fn deserialize_bytes(self, visitor: V) -> Result + where V: serde::de::Visitor<'de>, + { + let len: usize = try!(serde::Deserialize::deserialize(&mut *self)); + try!(self.read_bytes(len as u64)); + self.reader.forward_read_bytes(len, visitor) + } + + fn deserialize_byte_buf(self, visitor: V) -> Result + where V: serde::de::Visitor<'de>, + { + visitor.visit_byte_buf(try!(self.read_vec())) + } + + fn deserialize_enum(self, + _enum: &'static str, + _variants: &'static [&'static str], + visitor: V) -> Result + where V: serde::de::Visitor<'de>, + { + impl<'de, 'a, R: 'a, S, E> serde::de::EnumAccess<'de> for &'a mut Deserializer + where R: BincodeRead<'de>, S: SizeLimit, E: ByteOrder { + type Error = Error; + type Variant = Self; + + fn variant_seed(self, seed: V) -> Result<(V::Value, Self::Variant)> + where V: serde::de::DeserializeSeed<'de>, + { + let idx: u32 = try!(serde::de::Deserialize::deserialize(&mut *self)); + let val: Result<_> = seed.deserialize(idx.into_deserializer()); + Ok((try!(val), self)) + } + } + + visitor.visit_enum(self) + } + + fn deserialize_tuple(self, + len: usize, + visitor: V) -> Result + where V: serde::de::Visitor<'de>, + { + struct Access<'a, R: Read + 'a, S: SizeLimit + 'a, E: ByteOrder + 'a> { + deserializer: &'a mut Deserializer, + len: usize, + } + + impl<'de, 'a, 'b: 'a, R: BincodeRead<'de>+ 'b, S: SizeLimit, E: ByteOrder> serde::de::SeqAccess<'de> for Access<'a, R, S, E> { + type Error = Error; + + fn next_element_seed(&mut self, seed: T) -> Result> + where T: serde::de::DeserializeSeed<'de>, + { + if self.len > 0 { + self.len -= 1; + let value = try!(serde::de::DeserializeSeed::deserialize(seed, &mut *self.deserializer)); + Ok(Some(value)) + } else { + Ok(None) + } + } + + fn size_hint(&self) -> Option { + Some(self.len) + } + } + + visitor.visit_seq(Access { deserializer: self, len: len }) + } + + fn deserialize_option(self, visitor: V) -> Result + where V: serde::de::Visitor<'de>, + { + let value: u8 = try!(serde::de::Deserialize::deserialize(&mut *self)); + match value { + 0 => visitor.visit_none(), + 1 => visitor.visit_some(&mut *self), + _ => Err(ErrorKind::InvalidEncoding{ + desc: "invalid tag when decoding Option", + detail: Some(format!("Expected 0 or 1, got {}", value)) + }.into()), + } + } + + fn deserialize_seq(self, visitor: V) -> Result + where V: serde::de::Visitor<'de>, + { + let len = try!(serde::Deserialize::deserialize(&mut *self)); + + self.deserialize_tuple(len, visitor) + } + + fn deserialize_map(self, visitor: V) -> Result + where V: serde::de::Visitor<'de>, + { + struct Access<'a, R: Read + 'a, S: SizeLimit + 'a, E: ByteOrder + 'a> { + deserializer: &'a mut Deserializer, + len: usize, + } + + impl<'de, 'a, 'b: 'a, R: BincodeRead<'de> + 'b, S: SizeLimit, E: ByteOrder> serde::de::MapAccess<'de> for Access<'a, R, S, E> { + type Error = Error; + + fn next_key_seed(&mut self, seed: K) -> Result> + where K: serde::de::DeserializeSeed<'de>, + { + if self.len > 0 { + self.len -= 1; + let key = try!(serde::de::DeserializeSeed::deserialize(seed, &mut *self.deserializer)); + Ok(Some(key)) + } else { + Ok(None) + } + } + + fn next_value_seed(&mut self, seed: V) -> Result + where V: serde::de::DeserializeSeed<'de>, + { + let value = try!(serde::de::DeserializeSeed::deserialize(seed, &mut *self.deserializer)); + Ok(value) + } + + fn size_hint(&self) -> Option { + Some(self.len) + } + } + + let len = try!(serde::Deserialize::deserialize(&mut *self)); + + visitor.visit_map(Access { deserializer: self, len: len }) + } + + fn deserialize_struct(self, + _name: &str, + fields: &'static [&'static str], + visitor: V) -> Result + where V: serde::de::Visitor<'de>, + { + self.deserialize_tuple(fields.len(), visitor) + } + + fn deserialize_identifier(self, + _visitor: V) -> Result + where V: serde::de::Visitor<'de>, + { + let message = "bincode does not support Deserializer::deserialize_identifier"; + Err(Error::custom(message)) + } + + fn deserialize_newtype_struct(self, + _name: &str, + visitor: V) -> Result + where V: serde::de::Visitor<'de>, + { + visitor.visit_newtype_struct(self) + } + + fn deserialize_unit_struct(self, + _name: &'static str, + visitor: V) -> Result + where V: serde::de::Visitor<'de>, + { + visitor.visit_unit() + } + + fn deserialize_tuple_struct(self, + _name: &'static str, + len: usize, + visitor: V) -> Result + where V: serde::de::Visitor<'de>, + { + self.deserialize_tuple(len, visitor) + } + + fn deserialize_ignored_any(self, + _visitor: V) -> Result + where V: serde::de::Visitor<'de>, + { + let message = "bincode does not support Deserializer::deserialize_ignored_any"; + Err(Error::custom(message)) + } +} + +impl<'de, 'a, R, S, E> serde::de::VariantAccess<'de> for &'a mut Deserializer +where R: BincodeRead<'de>, S: SizeLimit, E: ByteOrder { + type Error = Error; + + fn unit_variant(self) -> Result<()> { + Ok(()) + } + + fn newtype_variant_seed(self, seed: T) -> Result + where T: serde::de::DeserializeSeed<'de>, + { + serde::de::DeserializeSeed::deserialize(seed, self) + } + + fn tuple_variant(self, + len: usize, + visitor: V) -> Result + where V: serde::de::Visitor<'de>, + { + serde::de::Deserializer::deserialize_tuple(self, len, visitor) + } + + fn struct_variant(self, + fields: &'static [&'static str], + visitor: V) -> Result + where V: serde::de::Visitor<'de>, + { + serde::de::Deserializer::deserialize_tuple(self, fields.len(), visitor) + } +} +static UTF8_CHAR_WIDTH: [u8; 256] = [ +1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1, +1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1, // 0x1F +1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1, +1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1, // 0x3F +1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1, +1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1, // 0x5F +1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1, +1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1, // 0x7F +0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0, +0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0, // 0x9F +0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0, +0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0, // 0xBF +0,0,2,2,2,2,2,2,2,2,2,2,2,2,2,2, +2,2,2,2,2,2,2,2,2,2,2,2,2,2,2,2, // 0xDF +3,3,3,3,3,3,3,3,3,3,3,3,3,3,3,3, // 0xEF +4,4,4,4,4,0,0,0,0,0,0,0,0,0,0,0, // 0xFF +]; + +fn utf8_char_width(b: u8) -> usize { + UTF8_CHAR_WIDTH[b as usize] as usize +} diff --git a/third_party/rust/bincode-0.8.0/src/de/read.rs b/third_party/rust/bincode-0.8.0/src/de/read.rs new file mode 100644 index 000000000000..c22ee230643a --- /dev/null +++ b/third_party/rust/bincode-0.8.0/src/de/read.rs @@ -0,0 +1,151 @@ +use std::io::{Read as IoRead, Result as IoResult, Error as IoError, ErrorKind as IoErrorKind}; +use ::Result; +use serde_crate as serde; + +/// A byte-oriented reading trait that is specialized for +/// slices and generic readers. +pub trait BincodeRead<'storage>: IoRead { + #[doc(hidden)] + fn forward_read_str(&mut self, length: usize, visitor: V) -> Result + where V: serde::de::Visitor<'storage>; + + #[doc(hidden)] + fn get_byte_buffer(&mut self, length: usize) -> Result>; + + #[doc(hidden)] + fn forward_read_bytes(&mut self, length: usize, visitor: V) -> Result + where V: serde::de::Visitor<'storage>; +} + +/// A BincodeRead implementation for byte slices +pub struct SliceReader<'storage> { + slice: &'storage [u8] +} + +/// A BincodeRead implementation for io::Readers +pub struct IoReadReader { + reader: R, + temp_buffer: Vec, +} + +impl <'storage> SliceReader<'storage> { + /// Constructs a slice reader + pub fn new(bytes: &'storage [u8]) -> SliceReader<'storage> { + SliceReader { + slice: bytes, + } + } +} + +impl IoReadReader { + /// Constructs an IoReadReader + pub fn new(r: R) -> IoReadReader { + IoReadReader { + reader: r, + temp_buffer: vec![], + } + } +} + +impl <'storage> IoRead for SliceReader<'storage> { + fn read(&mut self, out: & mut [u8]) -> IoResult { + (&mut self.slice).read(out) + } +} + +impl IoRead for IoReadReader { + fn read(&mut self, out: & mut [u8]) -> IoResult { + self.reader.read(out) + } +} + +impl <'storage> SliceReader<'storage> { + fn unexpected_eof() -> Box<::ErrorKind> { + return Box::new(::ErrorKind::IoError(IoError::new(IoErrorKind::UnexpectedEof, ""))); + } +} + +impl <'storage> BincodeRead<'storage> for SliceReader<'storage> { + fn forward_read_str(&mut self, length: usize, visitor: V) -> Result + where V: serde::de::Visitor<'storage> { + use ::ErrorKind; + if length > self.slice.len() { + return Err(SliceReader::unexpected_eof()); + } + + let string = match ::std::str::from_utf8(&self.slice[..length]) { + Ok(s) => s, + Err(_) => return Err(Box::new(ErrorKind::InvalidEncoding { + desc: "string was not valid utf8", + detail: None, + })), + }; + let r = visitor.visit_borrowed_str(string); + self.slice = &self.slice[length..]; + r + } + + fn get_byte_buffer(&mut self, length: usize) -> Result> { + if length > self.slice.len() { + return Err(SliceReader::unexpected_eof()); + } + + let r = &self.slice[..length]; + self.slice = &self.slice[length..]; + Ok(r.to_vec()) + } + + fn forward_read_bytes(&mut self, length: usize, visitor: V) -> Result + where V: serde::de::Visitor<'storage> { + if length > self.slice.len() { + return Err(SliceReader::unexpected_eof()); + } + + let r = visitor.visit_borrowed_bytes(&self.slice[..length]); + self.slice = &self.slice[length..]; + r + } +} + +impl IoReadReader where R: IoRead { + fn fill_buffer(&mut self, length: usize) -> Result<()> { + let current_length = self.temp_buffer.len(); + if length > current_length{ + self.temp_buffer.reserve_exact(length - current_length); + unsafe { self.temp_buffer.set_len(length); } + } + + self.reader.read_exact(&mut self.temp_buffer[..length])?; + Ok(()) + } +} + +impl BincodeRead<'static> for IoReadReader where R: IoRead { + fn forward_read_str(&mut self, length: usize, visitor: V) -> Result + where V: serde::de::Visitor<'static> { + self.fill_buffer(length)?; + + let string = match ::std::str::from_utf8(&self.temp_buffer[..length]) { + Ok(s) => s, + Err(_) => return Err(Box::new(::ErrorKind::InvalidEncoding { + desc: "string was not valid utf8", + detail: None, + })), + }; + + let r = visitor.visit_str(string); + r + } + + fn get_byte_buffer(&mut self, length: usize) -> Result> { + self.fill_buffer(length)?; + Ok(self.temp_buffer[..length].to_vec()) + } + + fn forward_read_bytes(&mut self, length: usize, visitor: V) -> Result + where V: serde::de::Visitor<'static> { + self.fill_buffer(length)?; + let r = visitor.visit_bytes(&self.temp_buffer[..length]); + r + } +} diff --git a/third_party/rust/bincode-0.8.0/src/internal.rs b/third_party/rust/bincode-0.8.0/src/internal.rs new file mode 100644 index 000000000000..d8aa74e318a0 --- /dev/null +++ b/third_party/rust/bincode-0.8.0/src/internal.rs @@ -0,0 +1,240 @@ +//! A collection of serialization and deserialization functions +//! that use the `serde` crate for the serializable and deserializable +//! implementation. + +use std::io::{Write, Read}; +use std::io::Error as IoError; +use std::{error, fmt, result}; +use ::SizeLimit; +use byteorder::{ByteOrder}; + +pub use super::de::{ + Deserializer, +}; + +pub use super::ser::{ + Serializer, +}; + +use super::ser::SizeChecker; + +use serde_crate as serde; + +/// The result of a serialization or deserialization operation. +pub type Result = result::Result; + +/// An error that can be produced during (de)serializing. +/// +/// If decoding from a Buffer, assume that the buffer has been left +/// in an invalid state. +pub type Error = Box; + +/// The kind of error that can be produced during a serialization or deserialization. +#[derive(Debug)] +pub enum ErrorKind { + /// If the error stems from the reader/writer that is being used + /// during (de)serialization, that error will be stored and returned here. + IoError(IoError), + /// If the bytes in the reader are not decodable because of an invalid + /// encoding, this error will be returned. This error is only possible + /// if a stream is corrupted. A stream produced from `encode` or `encode_into` + /// should **never** produce an InvalidEncoding error. + InvalidEncoding { + #[allow(missing_docs)] + desc: &'static str, + #[allow(missing_docs)] + detail: Option + }, + /// If (de)serializing a message takes more than the provided size limit, this + /// error is returned. + SizeLimit, + /// Bincode can not encode sequences of unknown length (like iterators). + SequenceMustHaveLength, + /// A custom error message from Serde. + Custom(String) +} + +impl error::Error for ErrorKind { + fn description(&self) -> &str { + match *self { + ErrorKind::IoError(ref err) => error::Error::description(err), + ErrorKind::InvalidEncoding{desc, ..} => desc, + ErrorKind::SequenceMustHaveLength => "bincode can't encode infinite sequences", + ErrorKind::SizeLimit => "the size limit for decoding has been reached", + ErrorKind::Custom(ref msg) => msg, + + } + } + + fn cause(&self) -> Option<&error::Error> { + match *self { + ErrorKind::IoError(ref err) => err.cause(), + ErrorKind::InvalidEncoding{..} => None, + ErrorKind::SequenceMustHaveLength => None, + ErrorKind::SizeLimit => None, + ErrorKind::Custom(_) => None, + } + } +} + +impl From for Error { + fn from(err: IoError) -> Error { + ErrorKind::IoError(err).into() + } +} + +impl fmt::Display for ErrorKind { + fn fmt(&self, fmt: &mut fmt::Formatter) -> fmt::Result { + match *self { + ErrorKind::IoError(ref ioerr) => + write!(fmt, "IoError: {}", ioerr), + ErrorKind::InvalidEncoding{desc, detail: None}=> + write!(fmt, "InvalidEncoding: {}", desc), + ErrorKind::InvalidEncoding{desc, detail: Some(ref detail)}=> + write!(fmt, "InvalidEncoding: {} ({})", desc, detail), + ErrorKind::SequenceMustHaveLength => + write!(fmt, "Bincode can only encode sequences and maps that have a knowable size ahead of time."), + ErrorKind::SizeLimit => + write!(fmt, "SizeLimit"), + ErrorKind::Custom(ref s) => + s.fmt(fmt), + } + } +} + +impl serde::de::Error for Error { + fn custom(desc: T) -> Error { + ErrorKind::Custom(desc.to_string()).into() + } +} + +impl serde::ser::Error for Error { + fn custom(msg: T) -> Self { + ErrorKind::Custom(msg.to_string()).into() + } +} + +/// Serializes an object directly into a `Writer`. +/// +/// If the serialization would take more bytes than allowed by `size_limit`, an error +/// is returned and *no bytes* will be written into the `Writer`. +/// +/// If this returns an `Error` (other than SizeLimit), assume that the +/// writer is in an invalid state, as writing could bail out in the middle of +/// serializing. +pub fn serialize_into(writer: &mut W, value: &T, size_limit: S) -> Result<()> + where W: Write, T: serde::Serialize, S: SizeLimit, E: ByteOrder +{ + if let Some(limit) = size_limit.limit() { + try!(serialized_size_bounded(value, limit).ok_or(ErrorKind::SizeLimit)); + } + + let mut serializer = Serializer::<_, E>::new(writer); + serde::Serialize::serialize(value, &mut serializer) +} + +/// Serializes a serializable object into a `Vec` of bytes. +/// +/// If the serialization would take more bytes than allowed by `size_limit`, +/// an error is returned. +pub fn serialize(value: &T, size_limit: S) -> Result> + where T: serde::Serialize, S: SizeLimit, E: ByteOrder +{ + let mut writer = match size_limit.limit() { + Some(size_limit) => { + let actual_size = try!(serialized_size_bounded(value, size_limit).ok_or(ErrorKind::SizeLimit)); + Vec::with_capacity(actual_size as usize) + } + None => { + let size = serialized_size(value) as usize; + Vec::with_capacity(size) + } + }; + + try!(serialize_into::<_, _, _, E>(&mut writer, value, super::Infinite)); + Ok(writer) +} + + +struct CountSize { + total: u64, + limit: Option, +} + +impl SizeLimit for CountSize { + fn add(&mut self, c: u64) -> Result<()> { + self.total += c; + if let Some(limit) = self.limit { + if self.total > limit { + return Err(Box::new(ErrorKind::SizeLimit)) + } + } + Ok(()) + } + + fn limit(&self) -> Option { + unreachable!(); + } +} + +/// Returns the size that an object would be if serialized using bincode. +/// +/// This is used internally as part of the check for encode_into, but it can +/// be useful for preallocating buffers if thats your style. +pub fn serialized_size(value: &T) -> u64 + where T: serde::Serialize +{ + let mut size_counter = SizeChecker { + size_limit: CountSize { total: 0, limit: None } + }; + + value.serialize(&mut size_counter).ok(); + size_counter.size_limit.total +} + +/// Given a maximum size limit, check how large an object would be if it +/// were to be serialized. +/// +/// If it can be serialized in `max` or fewer bytes, that number will be returned +/// inside `Some`. If it goes over bounds, then None is returned. +pub fn serialized_size_bounded(value: &T, max: u64) -> Option + where T: serde::Serialize +{ + let mut size_counter = SizeChecker { + size_limit: CountSize { total: 0, limit: Some(max) } + }; + + match value.serialize(&mut size_counter) { + Ok(_) => Some(size_counter.size_limit.total), + Err(_) => None, + } +} + +/// Deserializes an object directly from a `Buffer`ed Reader. +/// +/// If the provided `SizeLimit` is reached, the deserialization will bail immediately. +/// A SizeLimit can help prevent an attacker from flooding your server with +/// a neverending stream of values that runs your server out of memory. +/// +/// If this returns an `Error`, assume that the buffer that you passed +/// in is in an invalid state, as the error could be returned during any point +/// in the reading. +pub fn deserialize_from(reader: &mut R, size_limit: S) -> Result + where R: Read, T: serde::de::DeserializeOwned, S: SizeLimit, E: ByteOrder +{ + let reader = ::de::read::IoReadReader::new(reader); + let mut deserializer = Deserializer::<_, S, E>::new(reader, size_limit); + serde::Deserialize::deserialize(&mut deserializer) +} + +/// Deserializes a slice of bytes into an object. +/// +/// This method does not have a size-limit because if you already have the bytes +/// in memory, then you don't gain anything by having a limiter. +pub fn deserialize<'a, T, E: ByteOrder>(bytes: &'a [u8]) -> Result + where T: serde::de::Deserialize<'a>, +{ + let reader = ::de::read::SliceReader::new(bytes); + let mut deserializer = Deserializer::<_, _, E>::new(reader, super::Infinite); + serde::Deserialize::deserialize(&mut deserializer) +} diff --git a/third_party/rust/bincode-0.8.0/src/lib.rs b/third_party/rust/bincode-0.8.0/src/lib.rs new file mode 100644 index 000000000000..f4d76813c45d --- /dev/null +++ b/third_party/rust/bincode-0.8.0/src/lib.rs @@ -0,0 +1,167 @@ +#![deny(missing_docs)] + +//! `bincode` is a crate for encoding and decoding using a tiny binary +//! serialization strategy. +//! +//! There are simple functions for encoding to `Vec` and decoding from +//! `&[u8]`, but the meat of the library is the `encode_into` and `decode_from` +//! functions which respectively allow encoding into a `std::io::Writer` +//! and decoding from a `std::io::Buffer`. +//! +//! ## Modules +//! Until "default type parameters" lands, we have an extra module called `endian_choice` +//! that duplicates all of the core bincode functionality but with the option to choose +//! which endianness the integers are encoded using. +//! +//! The default endianness is little. +//! +//! ### Using Basic Functions +//! +//! ```rust +//! extern crate bincode; +//! use bincode::{serialize, deserialize, Bounded}; +//! fn main() { +//! // The object that we will serialize. +//! let target = Some("hello world".to_string()); +//! // The maximum size of the encoded message. +//! let limit = Bounded(20); +//! +//! let encoded: Vec = serialize(&target, limit).unwrap(); +//! let decoded: Option = deserialize(&encoded[..]).unwrap(); +//! assert_eq!(target, decoded); +//! } +//! ``` + +#![crate_name = "bincode"] +#![crate_type = "rlib"] +#![crate_type = "dylib"] + +extern crate byteorder; +extern crate num_traits; +extern crate serde as serde_crate; + +mod ser; +mod de; +pub mod internal; + +pub mod read_types { + //! The types that the deserializer uses for optimizations + pub use ::de::read::{SliceReader, BincodeRead, IoReadReader}; +} + +use std::io::{Read, Write}; + +pub use internal::{ErrorKind, Error, Result, serialized_size, serialized_size_bounded}; + +/// A Deserializer that uses LittleEndian byteorder +pub type Deserializer = internal::Deserializer; +/// A Serializer that uses LittleEndian byteorder +pub type Serializer = internal::Serializer; + +/// Deserializes a slice of bytes into an object. +/// +/// This method does not have a size-limit because if you already have the bytes +/// in memory, then you don't gain anything by having a limiter. +pub fn deserialize<'a, T>(bytes: &'a [u8]) -> internal::Result + where T: serde_crate::de::Deserialize<'a>, +{ + internal::deserialize::<_, byteorder::LittleEndian>(bytes) +} + +/// Deserializes an object directly from a `Buffer`ed Reader. +/// +/// If the provided `SizeLimit` is reached, the deserialization will bail immediately. +/// A SizeLimit can help prevent an attacker from flooding your server with +/// a neverending stream of values that runs your server out of memory. +/// +/// If this returns an `Error`, assume that the buffer that you passed +/// in is in an invalid state, as the error could be returned during any point +/// in the reading. +pub fn deserialize_from(reader: &mut R, size_limit: S) -> internal::Result + where R: Read, T: serde_crate::de::DeserializeOwned, S: SizeLimit +{ + internal::deserialize_from::<_, _, _, byteorder::LittleEndian>(reader, size_limit) +} + +/// Serializes an object directly into a `Writer`. +/// +/// If the serialization would take more bytes than allowed by `size_limit`, an error +/// is returned and *no bytes* will be written into the `Writer`. +/// +/// If this returns an `Error` (other than SizeLimit), assume that the +/// writer is in an invalid state, as writing could bail out in the middle of +/// serializing. +pub fn serialize_into(writer: &mut W, value: &T, size_limit: S) -> internal::Result<()> + where W: Write, T: serde_crate::Serialize, S: SizeLimit +{ + internal::serialize_into::<_, _, _, byteorder::LittleEndian>(writer, value, size_limit) +} + +/// Serializes a serializable object into a `Vec` of bytes. +/// +/// If the serialization would take more bytes than allowed by `size_limit`, +/// an error is returned. +pub fn serialize(value: &T, size_limit: S) -> internal::Result> + where T: serde_crate::Serialize, S: SizeLimit +{ + internal::serialize::<_, _, byteorder::LittleEndian>(value, size_limit) +} + +/// A limit on the amount of bytes that can be read or written. +/// +/// Size limits are an incredibly important part of both encoding and decoding. +/// +/// In order to prevent DOS attacks on a decoder, it is important to limit the +/// amount of bytes that a single encoded message can be; otherwise, if you +/// are decoding bytes right off of a TCP stream for example, it would be +/// possible for an attacker to flood your server with a 3TB vec, causing the +/// decoder to run out of memory and crash your application! +/// Because of this, you can provide a maximum-number-of-bytes that can be read +/// during decoding, and the decoder will explicitly fail if it has to read +/// any more than that. +/// +/// On the other side, you want to make sure that you aren't encoding a message +/// that is larger than your decoder expects. By supplying a size limit to an +/// encoding function, the encoder will verify that the structure can be encoded +/// within that limit. This verification occurs before any bytes are written to +/// the Writer, so recovering from an error is easy. +pub trait SizeLimit { + /// Tells the SizeLimit that a certain number of bytes has been + /// read or written. Returns Err if the limit has been exceeded. + fn add(&mut self, n: u64) -> Result<()>; + /// Returns the hard limit (if one exists) + fn limit(&self) -> Option; +} + +/// A SizeLimit that restricts serialized or deserialized messages from +/// exceeding a certain byte length. +#[derive(Copy, Clone)] +pub struct Bounded(pub u64); + +/// A SizeLimit without a limit! +/// Use this if you don't care about the size of encoded or decoded messages. +#[derive(Copy, Clone)] +pub struct Infinite; + +impl SizeLimit for Bounded { + #[inline(always)] + fn add(&mut self, n: u64) -> Result<()> { + if self.0 >= n { + self.0 -= n; + Ok(()) + } else { + Err(Box::new(ErrorKind::SizeLimit)) + } + } + + #[inline(always)] + fn limit(&self) -> Option { Some(self.0) } +} + +impl SizeLimit for Infinite { + #[inline(always)] + fn add(&mut self, _: u64) -> Result<()> { Ok (()) } + + #[inline(always)] + fn limit(&self) -> Option { None } +} diff --git a/third_party/rust/bincode-0.8.0/src/ser/mod.rs b/third_party/rust/bincode-0.8.0/src/ser/mod.rs new file mode 100644 index 000000000000..9082afab5d73 --- /dev/null +++ b/third_party/rust/bincode-0.8.0/src/ser/mod.rs @@ -0,0 +1,687 @@ +use std::io::Write; +use std::u32; +use std::marker::PhantomData; + +use serde_crate as serde; + +use byteorder::{WriteBytesExt, ByteOrder}; + +use super::{Result, Error, ErrorKind}; +use super::SizeLimit; + +/// An Serializer that encodes values directly into a Writer. +/// +/// The specified byte-order will impact the endianness that is +/// used during the encoding. +/// +/// This struct should not be used often. +/// For most cases, prefer the `encode_into` function. +pub struct Serializer { + writer: W, + _phantom: PhantomData, +} + +impl Serializer { + /// Creates a new Serializer with the given `Write`r. + pub fn new(w: W) -> Serializer { + Serializer { + writer: w, + _phantom: PhantomData, + } + } +} + +impl<'a, W: Write, E: ByteOrder> serde::Serializer for &'a mut Serializer { + type Ok = (); + type Error = Error; + type SerializeSeq = Compound<'a, W, E>; + type SerializeTuple = Compound<'a, W, E>; + type SerializeTupleStruct = Compound<'a, W, E>; + type SerializeTupleVariant = Compound<'a, W, E>; + type SerializeMap = Compound<'a, W, E>; + type SerializeStruct = Compound<'a, W, E>; + type SerializeStructVariant = Compound<'a, W, E>; + + fn serialize_unit(self) -> Result<()> { Ok(()) } + + fn serialize_unit_struct(self, _: &'static str) -> Result<()> { Ok(()) } + + fn serialize_bool(self, v: bool) -> Result<()> { + self.writer.write_u8(if v {1} else {0}).map_err(Into::into) + } + + fn serialize_u8(self, v: u8) -> Result<()> { + self.writer.write_u8(v).map_err(Into::into) + } + + fn serialize_u16(self, v: u16) -> Result<()> { + self.writer.write_u16::(v).map_err(Into::into) + } + + fn serialize_u32(self, v: u32) -> Result<()> { + self.writer.write_u32::(v).map_err(Into::into) + } + + fn serialize_u64(self, v: u64) -> Result<()> { + self.writer.write_u64::(v).map_err(Into::into) + } + + fn serialize_i8(self, v: i8) -> Result<()> { + self.writer.write_i8(v).map_err(Into::into) + } + + fn serialize_i16(self, v: i16) -> Result<()> { + self.writer.write_i16::(v).map_err(Into::into) + } + + fn serialize_i32(self, v: i32) -> Result<()> { + self.writer.write_i32::(v).map_err(Into::into) + } + + fn serialize_i64(self, v: i64) -> Result<()> { + self.writer.write_i64::(v).map_err(Into::into) + } + + fn serialize_f32(self, v: f32) -> Result<()> { + self.writer.write_f32::(v).map_err(Into::into) + } + + fn serialize_f64(self, v: f64) -> Result<()> { + self.writer.write_f64::(v).map_err(Into::into) + } + + fn serialize_str(self, v: &str) -> Result<()> { + try!(self.serialize_u64(v.len() as u64)); + self.writer.write_all(v.as_bytes()).map_err(Into::into) + } + + fn serialize_char(self, c: char) -> Result<()> { + self.writer.write_all(encode_utf8(c).as_slice()).map_err(Into::into) + } + + fn serialize_bytes(self, v: &[u8]) -> Result<()> { + try!(self.serialize_u64(v.len() as u64)); + self.writer.write_all(v).map_err(Into::into) + } + + fn serialize_none(self) -> Result<()> { + self.writer.write_u8(0).map_err(Into::into) + } + + fn serialize_some(self, v: &T) -> Result<()> + where T: serde::Serialize, + { + try!(self.writer.write_u8(1)); + v.serialize(self) + } + + fn serialize_seq(self, len: Option) -> Result { + let len = try!(len.ok_or(ErrorKind::SequenceMustHaveLength)); + try!(self.serialize_u64(len as u64)); + Ok(Compound {ser: self}) + } + + fn serialize_tuple(self, _len: usize) -> Result { + Ok(Compound {ser: self}) + } + + fn serialize_tuple_struct(self, _name: &'static str, _len: usize) -> Result { + Ok(Compound {ser: self}) + } + + fn serialize_tuple_variant(self, + _name: &'static str, + variant_index: u32, + _variant: &'static str, + _len: usize) -> Result + { + try!(self.serialize_u32(variant_index)); + Ok(Compound {ser: self}) + } + + fn serialize_map(self, len: Option) -> Result { + let len = try!(len.ok_or(ErrorKind::SequenceMustHaveLength)); + try!(self.serialize_u64(len as u64)); + Ok(Compound {ser: self}) + } + + fn serialize_struct(self, _name: &'static str, _len: usize) -> Result { + Ok(Compound {ser: self}) + } + + fn serialize_struct_variant(self, + _name: &'static str, + variant_index: u32, + _variant: &'static str, + _len: usize) -> Result + { + try!(self.serialize_u32(variant_index)); + Ok(Compound {ser: self}) + } + + fn serialize_newtype_struct(self, + _name: &'static str, + value: &T) -> Result<()> + where T: serde::ser::Serialize, + { + value.serialize(self) + } + + fn serialize_newtype_variant(self, + _name: &'static str, + variant_index: u32, + _variant: &'static str, + value: &T) -> Result<()> + where T: serde::ser::Serialize, + { + try!(self.serialize_u32(variant_index)); + value.serialize(self) + } + + fn serialize_unit_variant(self, + _name: &'static str, + variant_index: u32, + _variant: &'static str) -> Result<()> { + self.serialize_u32(variant_index) + } +} + +pub struct SizeChecker { + pub size_limit: S, +} + +impl SizeChecker { + pub fn new(size_limit: S) -> SizeChecker { + SizeChecker { + size_limit: size_limit + } + } + + fn add_raw(&mut self, size: u64) -> Result<()> { + self.size_limit.add(size) + } + + fn add_value(&mut self, t: T) -> Result<()> { + use std::mem::size_of_val; + self.add_raw(size_of_val(&t) as u64) + } +} + +impl<'a, S: SizeLimit> serde::Serializer for &'a mut SizeChecker { + type Ok = (); + type Error = Error; + type SerializeSeq = SizeCompound<'a, S>; + type SerializeTuple = SizeCompound<'a, S>; + type SerializeTupleStruct = SizeCompound<'a, S>; + type SerializeTupleVariant = SizeCompound<'a, S>; + type SerializeMap = SizeCompound<'a, S>; + type SerializeStruct = SizeCompound<'a, S>; + type SerializeStructVariant = SizeCompound<'a, S>; + + fn serialize_unit(self) -> Result<()> { Ok(()) } + + fn serialize_unit_struct(self, _: &'static str) -> Result<()> { Ok(()) } + + fn serialize_bool(self, _: bool) -> Result<()> { + self.add_value(0 as u8) + } + + fn serialize_u8(self, v: u8) -> Result<()> { + self.add_value(v) + } + + fn serialize_u16(self, v: u16) -> Result<()> { + self.add_value(v) + } + + fn serialize_u32(self, v: u32) -> Result<()> { + self.add_value(v) + } + + fn serialize_u64(self, v: u64) -> Result<()> { + self.add_value(v) + } + + fn serialize_i8(self, v: i8) -> Result<()> { + self.add_value(v) + } + + fn serialize_i16(self, v: i16) -> Result<()> { + self.add_value(v) + } + + fn serialize_i32(self, v: i32) -> Result<()> { + self.add_value(v) + } + + fn serialize_i64(self, v: i64) -> Result<()> { + self.add_value(v) + } + + fn serialize_f32(self, v: f32) -> Result<()> { + self.add_value(v) + } + + fn serialize_f64(self, v: f64) -> Result<()> { + self.add_value(v) + } + + fn serialize_str(self, v: &str) -> Result<()> { + try!(self.add_value(0 as u64)); + self.add_raw(v.len() as u64) + } + + fn serialize_char(self, c: char) -> Result<()> { + self.add_raw(encode_utf8(c).as_slice().len() as u64) + } + + fn serialize_bytes(self, v: &[u8]) -> Result<()> { + try!(self.add_value(0 as u64)); + self.add_raw(v.len() as u64) + } + + fn serialize_none(self) -> Result<()> { + self.add_value(0 as u8) + } + + fn serialize_some(self, v: &T) -> Result<()> + where T: serde::Serialize, + { + try!(self.add_value(1 as u8)); + v.serialize(self) + } + + fn serialize_seq(self, len: Option) -> Result { + let len = try!(len.ok_or(ErrorKind::SequenceMustHaveLength)); + + try!(self.serialize_u64(len as u64)); + Ok(SizeCompound {ser: self}) + } + + fn serialize_tuple(self, _len: usize) -> Result { + Ok(SizeCompound {ser: self}) + } + + fn serialize_tuple_struct(self, _name: &'static str, _len: usize) -> Result { + Ok(SizeCompound {ser: self}) + } + + fn serialize_tuple_variant(self, + _name: &'static str, + variant_index: u32, + _variant: &'static str, + _len: usize) -> Result + { + try!(self.add_value(variant_index)); + Ok(SizeCompound {ser: self}) + } + + fn serialize_map(self, len: Option) -> Result + { + let len = try!(len.ok_or(ErrorKind::SequenceMustHaveLength)); + + try!(self.serialize_u64(len as u64)); + Ok(SizeCompound {ser: self}) + } + + fn serialize_struct(self, _name: &'static str, _len: usize) -> Result { + Ok(SizeCompound {ser: self}) + } + + fn serialize_struct_variant(self, + _name: &'static str, + variant_index: u32, + _variant: &'static str, + _len: usize) -> Result + { + try!(self.add_value(variant_index)); + Ok(SizeCompound {ser: self}) + } + + fn serialize_newtype_struct(self, _name: &'static str, v: &V) -> Result<()> { + v.serialize(self) + } + + fn serialize_unit_variant(self, + _name: &'static str, + variant_index: u32, + _variant: &'static str) -> Result<()> { + self.add_value(variant_index) + } + + fn serialize_newtype_variant(self, + _name: &'static str, + variant_index: u32, + _variant: &'static str, + value: &V) -> Result<()> + { + try!(self.add_value(variant_index)); + value.serialize(self) + } +} + +#[doc(hidden)] +pub struct Compound<'a, W: 'a, E: ByteOrder + 'a> { + ser: &'a mut Serializer, +} + +impl<'a, W, E> serde::ser::SerializeSeq for Compound<'a, W, E> + where W: Write, E: ByteOrder +{ + type Ok = (); + type Error = Error; + + #[inline] + fn serialize_element(&mut self, value: &T) -> Result<()> + where T: serde::ser::Serialize + { + value.serialize(&mut *self.ser) + } + + #[inline] + fn end(self) -> Result<()> { + Ok(()) + } +} + +impl<'a, W, E> serde::ser::SerializeTuple for Compound<'a, W, E> + where W: Write, E: ByteOrder +{ + type Ok = (); + type Error = Error; + + #[inline] + fn serialize_element(&mut self, value: &T) -> Result<()> + where T: serde::ser::Serialize + { + value.serialize(&mut *self.ser) + } + + #[inline] + fn end(self) -> Result<()> { + Ok(()) + } +} + +impl<'a, W, E> serde::ser::SerializeTupleStruct for Compound<'a, W, E> + where W: Write, E: ByteOrder +{ + type Ok = (); + type Error = Error; + + #[inline] + fn serialize_field(&mut self, value: &T) -> Result<()> + where T: serde::ser::Serialize + { + value.serialize(&mut *self.ser) + } + + #[inline] + fn end(self) -> Result<()> { + Ok(()) + } +} + +impl<'a, W, E> serde::ser::SerializeTupleVariant for Compound<'a, W, E> + where W: Write, E: ByteOrder +{ + type Ok = (); + type Error = Error; + + #[inline] + fn serialize_field(&mut self, value: &T) -> Result<()> + where T: serde::ser::Serialize + { + value.serialize(&mut *self.ser) + } + + #[inline] + fn end(self) -> Result<()> { + Ok(()) + } +} + +impl<'a, W, E> serde::ser::SerializeMap for Compound<'a, W, E> + where W: Write, E: ByteOrder +{ + type Ok = (); + type Error = Error; + + #[inline] + fn serialize_key(&mut self, value: &K) -> Result<()> + where K: serde::ser::Serialize + { + value.serialize(&mut *self.ser) + } + + #[inline] + fn serialize_value(&mut self, value: &V) -> Result<()> + where V: serde::ser::Serialize + { + value.serialize(&mut *self.ser) + } + + #[inline] + fn end(self) -> Result<()> { + Ok(()) + } +} + +impl<'a, W, E> serde::ser::SerializeStruct for Compound<'a, W, E> + where W: Write, E: ByteOrder +{ + type Ok = (); + type Error = Error; + + #[inline] + fn serialize_field(&mut self, _key: &'static str, value: &T) -> Result<()> + where T: serde::ser::Serialize + { + value.serialize(&mut *self.ser) + } + + #[inline] + fn end(self) -> Result<()> { + Ok(()) + } +} + +impl<'a, W, E> serde::ser::SerializeStructVariant for Compound<'a, W, E> + where W: Write, E: ByteOrder +{ + type Ok = (); + type Error = Error; + + #[inline] + fn serialize_field(&mut self, _key: &'static str, value: &T) -> Result<()> + where T: serde::ser::Serialize + { + value.serialize(&mut *self.ser) + } + + #[inline] + fn end(self) -> Result<()> { + Ok(()) + } +} + +#[doc(hidden)] +pub struct SizeCompound<'a, S: SizeLimit + 'a> { + ser: &'a mut SizeChecker, +} + +impl<'a, S: SizeLimit> serde::ser::SerializeSeq for SizeCompound<'a, S> +{ + type Ok = (); + type Error = Error; + + #[inline] + fn serialize_element(&mut self, value: &T) -> Result<()> + where T: serde::ser::Serialize + { + value.serialize(&mut *self.ser) + } + + #[inline] + fn end(self) -> Result<()> { + Ok(()) + } +} + +impl<'a, S: SizeLimit> serde::ser::SerializeTuple for SizeCompound<'a, S> +{ + type Ok = (); + type Error = Error; + + #[inline] + fn serialize_element(&mut self, value: &T) -> Result<()> + where T: serde::ser::Serialize + { + value.serialize(&mut *self.ser) + } + + #[inline] + fn end(self) -> Result<()> { + Ok(()) + } +} + +impl<'a, S: SizeLimit> serde::ser::SerializeTupleStruct for SizeCompound<'a, S> +{ + type Ok = (); + type Error = Error; + + #[inline] + fn serialize_field(&mut self, value: &T) -> Result<()> + where T: serde::ser::Serialize + { + value.serialize(&mut *self.ser) + } + + #[inline] + fn end(self) -> Result<()> { + Ok(()) + } +} + +impl<'a, S: SizeLimit> serde::ser::SerializeTupleVariant for SizeCompound<'a, S> +{ + type Ok = (); + type Error = Error; + + #[inline] + fn serialize_field(&mut self, value: &T) -> Result<()> + where T: serde::ser::Serialize + { + value.serialize(&mut *self.ser) + } + + #[inline] + fn end(self) -> Result<()> { + Ok(()) + } +} + +impl<'a, S: SizeLimit + 'a> serde::ser::SerializeMap for SizeCompound<'a, S> +{ + type Ok = (); + type Error = Error; + + #[inline] + fn serialize_key(&mut self, value: &K) -> Result<()> + where K: serde::ser::Serialize + { + value.serialize(&mut *self.ser) + } + + #[inline] + fn serialize_value(&mut self, value: &V) -> Result<()> + where V: serde::ser::Serialize + { + value.serialize(&mut *self.ser) + } + + #[inline] + fn end(self) -> Result<()> { + Ok(()) + } +} + +impl<'a, S: SizeLimit> serde::ser::SerializeStruct for SizeCompound<'a, S> +{ + type Ok = (); + type Error = Error; + + #[inline] + fn serialize_field(&mut self, _key: &'static str, value: &T) -> Result<()> + where T: serde::ser::Serialize + { + value.serialize(&mut *self.ser) + } + + #[inline] + fn end(self) -> Result<()> { + Ok(()) + } +} + +impl<'a, S: SizeLimit> serde::ser::SerializeStructVariant for SizeCompound<'a, S> +{ + type Ok = (); + type Error = Error; + + #[inline] + fn serialize_field(&mut self, _key: &'static str, value: &T) -> Result<()> + where T: serde::ser::Serialize + { + value.serialize(&mut *self.ser) + } + + #[inline] + fn end(self) -> Result<()> { + Ok(()) + } +} +const TAG_CONT: u8 = 0b1000_0000; +const TAG_TWO_B: u8 = 0b1100_0000; +const TAG_THREE_B: u8 = 0b1110_0000; +const TAG_FOUR_B: u8 = 0b1111_0000; +const MAX_ONE_B: u32 = 0x80; +const MAX_TWO_B: u32 = 0x800; +const MAX_THREE_B: u32 = 0x10000; + +fn encode_utf8(c: char) -> EncodeUtf8 { + let code = c as u32; + let mut buf = [0; 4]; + let pos = if code < MAX_ONE_B { + buf[3] = code as u8; + 3 + } else if code < MAX_TWO_B { + buf[2] = (code >> 6 & 0x1F) as u8 | TAG_TWO_B; + buf[3] = (code & 0x3F) as u8 | TAG_CONT; + 2 + } else if code < MAX_THREE_B { + buf[1] = (code >> 12 & 0x0F) as u8 | TAG_THREE_B; + buf[2] = (code >> 6 & 0x3F) as u8 | TAG_CONT; + buf[3] = (code & 0x3F) as u8 | TAG_CONT; + 1 + } else { + buf[0] = (code >> 18 & 0x07) as u8 | TAG_FOUR_B; + buf[1] = (code >> 12 & 0x3F) as u8 | TAG_CONT; + buf[2] = (code >> 6 & 0x3F) as u8 | TAG_CONT; + buf[3] = (code & 0x3F) as u8 | TAG_CONT; + 0 + }; + EncodeUtf8 { buf: buf, pos: pos } +} + +struct EncodeUtf8 { + buf: [u8; 4], + pos: usize, +} + +impl EncodeUtf8 { + fn as_slice(&self) -> &[u8] { + &self.buf[self.pos..] + } +} diff --git a/third_party/rust/bincode-0.8.0/tests/test.rs b/third_party/rust/bincode-0.8.0/tests/test.rs new file mode 100644 index 000000000000..db0031b775fc --- /dev/null +++ b/third_party/rust/bincode-0.8.0/tests/test.rs @@ -0,0 +1,419 @@ +#[macro_use] +extern crate serde_derive; + +extern crate bincode; +extern crate serde; +extern crate serde_bytes; +extern crate byteorder; + +use std::fmt::Debug; +use std::collections::HashMap; +use std::borrow::Cow; + +use bincode::{Infinite, Bounded}; +use bincode::{serialized_size, ErrorKind, Result}; +use bincode::internal::{serialize, deserialize, deserialize_from}; + +use bincode::serialize as serialize_little; +use bincode::deserialize as deserialize_little; +use bincode::deserialize_from as deserialize_from_little; + +fn the_same(element: V) + where V: serde::Serialize+serde::de::DeserializeOwned+PartialEq+Debug+'static +{ + let size = serialized_size(&element); + + { + let encoded = serialize_little(&element, Infinite).unwrap(); + let decoded = deserialize_little(&encoded[..]).unwrap(); + + assert_eq!(element, decoded); + assert_eq!(size, encoded.len() as u64); + } + + { + let encoded = serialize::<_, _, byteorder::BigEndian>(&element, Infinite).unwrap(); + let decoded = deserialize::<_, byteorder::BigEndian>(&encoded[..]).unwrap(); + let decoded_reader = deserialize_from::<_, _, _, byteorder::BigEndian>(&mut &encoded[..], Infinite).unwrap(); + + assert_eq!(element, decoded); + assert_eq!(element, decoded_reader); + assert_eq!(size, encoded.len() as u64); + } +} + +#[test] +fn test_numbers() { + // unsigned positive + the_same(5u8); + the_same(5u16); + the_same(5u32); + the_same(5u64); + the_same(5usize); + // signed positive + the_same(5i8); + the_same(5i16); + the_same(5i32); + the_same(5i64); + the_same(5isize); + // signed negative + the_same(-5i8); + the_same(-5i16); + the_same(-5i32); + the_same(-5i64); + the_same(-5isize); + // floating + the_same(-100f32); + the_same(0f32); + the_same(5f32); + the_same(-100f64); + the_same(5f64); +} + +#[test] +fn test_string() { + the_same("".to_string()); + the_same("a".to_string()); +} + +#[test] +fn test_tuple() { + the_same((1isize,)); + the_same((1isize,2isize,3isize)); + the_same((1isize,"foo".to_string(),())); +} + +#[test] +fn test_basic_struct() { + #[derive(Serialize, Deserialize, PartialEq, Debug)] + struct Easy { + x: isize, + s: String, + y: usize + } + the_same(Easy{x: -4, s: "foo".to_string(), y: 10}); +} + +#[test] +fn test_nested_struct() { + #[derive(Serialize, Deserialize, PartialEq, Debug)] + struct Easy { + x: isize, + s: String, + y: usize + } + #[derive(Serialize, Deserialize, PartialEq, Debug)] + struct Nest { + f: Easy, + b: usize, + s: Easy + } + + the_same(Nest { + f: Easy {x: -1, s: "foo".to_string(), y: 20}, + b: 100, + s: Easy {x: -100, s: "bar".to_string(), y: 20} + }); +} + +#[test] +fn test_struct_newtype() { + #[derive(Serialize, Deserialize, PartialEq, Debug)] + struct NewtypeStr(usize); + + the_same(NewtypeStr(5)); +} + +#[test] +fn test_struct_tuple() { + #[derive(Serialize, Deserialize, PartialEq, Debug)] + struct TubStr(usize, String, f32); + + the_same(TubStr(5, "hello".to_string(), 3.2)); +} + +#[test] +fn test_option() { + the_same(Some(5usize)); + the_same(Some("foo bar".to_string())); + the_same(None::); +} + +#[test] +fn test_enum() { + #[derive(Serialize, Deserialize, PartialEq, Debug)] + enum TestEnum { + NoArg, + OneArg(usize), + Args(usize, usize), + AnotherNoArg, + StructLike{x: usize, y: f32} + } + the_same(TestEnum::NoArg); + the_same(TestEnum::OneArg(4)); + //the_same(TestEnum::Args(4, 5)); + the_same(TestEnum::AnotherNoArg); + the_same(TestEnum::StructLike{x: 4, y: 3.14159}); + the_same(vec![TestEnum::NoArg, TestEnum::OneArg(5), TestEnum::AnotherNoArg, + TestEnum::StructLike{x: 4, y:1.4}]); +} + +#[test] +fn test_vec() { + let v: Vec = vec![]; + the_same(v); + the_same(vec![1u64]); + the_same(vec![1u64,2,3,4,5,6]); +} + +#[test] +fn test_map() { + let mut m = HashMap::new(); + m.insert(4u64, "foo".to_string()); + m.insert(0u64, "bar".to_string()); + the_same(m); +} + +#[test] +fn test_bool() { + the_same(true); + the_same(false); +} + +#[test] +fn test_unicode() { + the_same("å".to_string()); + the_same("aåååååååa".to_string()); +} + +#[test] +fn test_fixed_size_array() { + the_same([24u32; 32]); + the_same([1u64, 2, 3, 4, 5, 6, 7, 8]); + the_same([0u8; 19]); +} + +#[test] +fn deserializing_errors() { + fn isize_invalid_deserialize(res: Result) { + match res.map_err(|e| *e) { + Err(ErrorKind::InvalidEncoding{..}) => {}, + Err(ErrorKind::Custom(ref s)) if s.contains("invalid encoding") => {}, + Err(ErrorKind::Custom(ref s)) if s.contains("invalid value") => {}, + other => panic!("Expecting InvalidEncoding, got {:?}", other), + } + } + + isize_invalid_deserialize(deserialize_little::(&vec![0xA][..])); + isize_invalid_deserialize(deserialize_little::(&vec![1, 0, 0, 0, 0, 0, 0, 0, 0xFF][..])); + // Out-of-bounds variant + #[derive(Serialize, Deserialize, Debug)] + enum Test { + One, + Two, + }; + isize_invalid_deserialize(deserialize_little::(&vec![0, 0, 0, 5][..])); + isize_invalid_deserialize(deserialize_little::>(&vec![5, 0][..])); +} + +#[test] +fn too_big_deserialize() { + let serialized = vec![0,0,0,3]; + let deserialized: Result = deserialize_from_little::<_, _, _>(&mut &serialized[..], Bounded(3)); + assert!(deserialized.is_err()); + + let serialized = vec![0,0,0,3]; + let deserialized: Result = deserialize_from_little::<_, _, _>(&mut &serialized[..], Bounded(4)); + assert!(deserialized.is_ok()); +} + +#[test] +fn char_serialization() { + let chars = "Aa\0☺♪"; + for c in chars.chars() { + let encoded = serialize_little(&c, Bounded(4)).expect("serializing char failed"); + let decoded: char = deserialize_little(&encoded).expect("deserializing failed"); + assert_eq!(decoded, c); + } +} + +#[test] +fn too_big_char_deserialize() { + let serialized = vec![0x41]; + let deserialized: Result = deserialize_from_little::<_, _, _>(&mut &serialized[..], Bounded(1)); + assert!(deserialized.is_ok()); + assert_eq!(deserialized.unwrap(), 'A'); +} + +#[test] +fn too_big_serialize() { + assert!(serialize_little(&0u32, Bounded(3)).is_err()); + assert!(serialize_little(&0u32, Bounded(4)).is_ok()); + + assert!(serialize_little(&"abcde", Bounded(8 + 4)).is_err()); + assert!(serialize_little(&"abcde", Bounded(8 + 5)).is_ok()); +} + +#[test] +fn test_proxy_encoded_size() { + assert!(serialized_size(&0u8) == 1); + assert!(serialized_size(&0u16) == 2); + assert!(serialized_size(&0u32) == 4); + assert!(serialized_size(&0u64) == 8); + + // length isize stored as u64 + assert!(serialized_size(&"") == 8); + assert!(serialized_size(&"a") == 8 + 1); + + assert!(serialized_size(&vec![0u32, 1u32, 2u32]) == 8 + 3 * (4)) + +} + +#[test] +fn test_serialized_size() { + assert!(serialized_size(&0u8) == 1); + assert!(serialized_size(&0u16) == 2); + assert!(serialized_size(&0u32) == 4); + assert!(serialized_size(&0u64) == 8); + + // length isize stored as u64 + assert!(serialized_size(&"") == 8); + assert!(serialized_size(&"a") == 8 + 1); + + assert!(serialized_size(&vec![0u32, 1u32, 2u32]) == 8 + 3 * (4)) +} + +#[test] +fn encode_box() { + the_same(Box::new(5)); +} + +#[test] +fn test_cow_serialize() { + let large_object = vec![1u32,2,3,4,5,6]; + let mut large_map = HashMap::new(); + large_map.insert(1, 2); + + + #[derive(Serialize, Deserialize, Debug)] + enum Message<'a> { + M1(Cow<'a, Vec>), + M2(Cow<'a, HashMap>) + } + + // Test 1 + { + let serialized = serialize_little(&Message::M1(Cow::Borrowed(&large_object)), Infinite).unwrap(); + let deserialized: Message<'static> = deserialize_from_little(&mut &serialized[..], Infinite).unwrap(); + + match deserialized { + Message::M1(b) => assert!(&b.into_owned() == &large_object), + _ => assert!(false) + } + } + + // Test 2 + { + let serialized = serialize_little(&Message::M2(Cow::Borrowed(&large_map)), Infinite).unwrap(); + let deserialized: Message<'static> = deserialize_from_little(&mut &serialized[..], Infinite).unwrap(); + + match deserialized { + Message::M2(b) => assert!(&b.into_owned() == &large_map), + _ => assert!(false) + } + } +} + +#[test] +fn test_strbox_serialize() { + let strx: &'static str = "hello world"; + let serialized = serialize_little(&Cow::Borrowed(strx), Infinite).unwrap(); + let deserialized: Cow<'static, String> = deserialize_from_little(&mut &serialized[..], Infinite).unwrap(); + let stringx: String = deserialized.into_owned(); + assert!(strx == &stringx[..]); +} + +#[test] +fn test_slicebox_serialize() { + let slice = [1u32, 2, 3 ,4, 5]; + let serialized = serialize_little(&Cow::Borrowed(&slice[..]), Infinite).unwrap(); + println!("{:?}", serialized); + let deserialized: Cow<'static, Vec> = deserialize_from_little(&mut &serialized[..], Infinite).unwrap(); + { + let sb: &[u32] = &deserialized; + assert!(slice == sb); + } + let vecx: Vec = deserialized.into_owned(); + assert!(slice == &vecx[..]); +} + +#[test] +fn test_multi_strings_serialize() { + assert!(serialize_little(&("foo", "bar", "baz"), Infinite).is_ok()); +} + +#[test] +fn test_oom_protection() { + use std::io::Cursor; + #[derive(Serialize, Deserialize, PartialEq, Debug)] + struct FakeVec { + len: u64, + byte: u8 + } + let x = serialize_little(&FakeVec { len: 0xffffffffffffffffu64, byte: 1 }, Bounded(10)).unwrap(); + let y: Result> = deserialize_from_little(&mut Cursor::new(&x[..]), Bounded(10)); + assert!(y.is_err()); +} + +#[test] +fn path_buf() { + use std::path::{Path, PathBuf}; + let path = Path::new("foo").to_path_buf(); + let serde_encoded = serialize_little(&path, Infinite).unwrap(); + let decoded: PathBuf = deserialize_little(&serde_encoded).unwrap(); + assert!(path.to_str() == decoded.to_str()); +} + +#[test] +fn bytes() { + use serde_bytes::Bytes; + + let data = b"abc\0123"; + let s = serialize_little(&data[..], Infinite).unwrap(); + let s2 = serialize_little(&Bytes::new(data), Infinite).unwrap(); + assert_eq!(s[..], s2[..]); +} + +#[test] +fn serde_bytes() { + use serde_bytes::ByteBuf; + the_same(ByteBuf::from(vec![1,2,3,4,5])); +} + + +#[test] +fn endian_difference() { + let x = 10u64; + let little = serialize_little(&x, Infinite).unwrap(); + let big = serialize::<_, _, byteorder::BigEndian>(&x, Infinite).unwrap(); + assert_ne!(little, big); +} + +#[test] +fn test_zero_copy_parse() { + #[derive(Serialize, Deserialize, Eq, PartialEq, Debug)] + struct Foo<'a> { + borrowed_str: &'a str, + borrowed_bytes: &'a [u8], + } + + let f = Foo { + borrowed_str: "hi", + borrowed_bytes: &[0, 1, 2, 3], + }; + { + let encoded = serialize_little(&f, Infinite).unwrap(); + let out: Foo = deserialize_little(&encoded[..]).unwrap(); + assert_eq!(out, f); + } +} diff --git a/third_party/rust/bincode/.cargo-checksum.json b/third_party/rust/bincode/.cargo-checksum.json index 0d32e2459106..c0e3a7aa5b05 100644 --- a/third_party/rust/bincode/.cargo-checksum.json +++ b/third_party/rust/bincode/.cargo-checksum.json @@ -1 +1 @@ -{"files":{".cargo-ok":"e3b0c44298fc1c149afbf4c8996fb92427ae41e4649b934ca495991b7852b855",".travis.yml":"f705a11b487bf71c41ebd8223cc1f3cbde0dfdfeea96a100af55e06e93397a1b","Cargo.toml":"b3ef32df664d22cfe4526f0022c8789e8976970b9e0982e1dd52f4f811134515","LICENSE.md":"90d7e062634054e6866d3c81e6a2b3058a840e6af733e98e80bdfe1a7dec6912","changelist.org":"936b58455e1c221539b73b5250302dcd96baa04a5d8536199d3351142addad57","examples/basic.rs":"ef6ab76936c8322b9f89fe8308311339c0bf7b413c5f88b5314b0035d49917a3","logo.png":"ebc5305aae938c1f834cf35302faa8be0f1b7b8c3c3beef5cf6b2f68b9628c35","readme.dev.md":"43bad3bcc13a5c057344d3ba7f64bd2b313f8c133d6afa068108df73e8e8facd","readme.md":"ca48b4a712089d792d449ef6e0e399efaf227dbcfcb141540684a16a2763583b","src/de/mod.rs":"8651e00130bd062e2305dcce8b68d777fff9877688e776b239778e18046dddaf","src/de/read.rs":"5abca51c6f0d93cc144914ed30bf2cfd0074ced09a0de8c3983997aaa471562d","src/internal.rs":"d9448e8467caf4cf24703626dab9e0d9420e98419e323ad7e611e4aeab525e4a","src/lib.rs":"998b85e103f8f5480ffeef43bd8430a66c061011055a053377f37dce32bf9088","src/ser/mod.rs":"0eeb467eeb8189fb935e4996cd45d1f292c401f92b00793907bd428f1bde421d","tests/test.rs":"26598b882a691caa5301a569e56e31567bfba5ffeab6f0ca67ebd95bfae679b0"},"package":"e103c8b299b28a9c6990458b7013dc4a8356a9b854c51b9883241f5866fac36e"} \ No newline at end of file +{"files":{".cargo-ok":"e3b0c44298fc1c149afbf4c8996fb92427ae41e4649b934ca495991b7852b855",".travis.yml":"f705a11b487bf71c41ebd8223cc1f3cbde0dfdfeea96a100af55e06e93397a1b","Cargo.toml":"f84aff9184ddcf55e949223d373eb6e25bd50a15d62cda08967c001997658239","LICENSE.md":"90d7e062634054e6866d3c81e6a2b3058a840e6af733e98e80bdfe1a7dec6912","changelist.org":"936b58455e1c221539b73b5250302dcd96baa04a5d8536199d3351142addad57","examples/basic.rs":"6c897fac722343138db14911da8d08c65cfd8d9a8143a5169845914897af8e21","logo.png":"ebc5305aae938c1f834cf35302faa8be0f1b7b8c3c3beef5cf6b2f68b9628c35","readme.dev.md":"43bad3bcc13a5c057344d3ba7f64bd2b313f8c133d6afa068108df73e8e8facd","readme.md":"a0cf9077393f746baa131934b53780d78e7807f8ce3f71d97347c657aebf5a0a","src/de/mod.rs":"be66fad5844a0b89025a089ab114540ab7ca6fa867cd2d72383af06c9ee30345","src/de/read.rs":"7ad8a1ae881ce135c3a56af66a3c83dad3f66722a3d21ad5c7addf0460d0edf3","src/internal.rs":"60e1c3fac7d8e6b01dc362b3171e2b4d2d8809fcbc98dc2431fffa01da6b63ae","src/lib.rs":"5bb0c0be61c8a7d9c1ef6209e05e25d44ae23e0b9b4a2adc0ae4264d35ea849b","src/ser/mod.rs":"0eeb467eeb8189fb935e4996cd45d1f292c401f92b00793907bd428f1bde421d","tests/test.rs":"a0116953ec3a3d6b9a9fc202d1bc886c5bb95110f2a3d4ac52e5945e4f6d182e"},"package":"9d3fb369af639822830328794eba2501b3479652fcd021b2aeb1ed4984202afd"} \ No newline at end of file diff --git a/third_party/rust/bincode/Cargo.toml b/third_party/rust/bincode/Cargo.toml index ddf68cbed21a..609ccc828465 100644 --- a/third_party/rust/bincode/Cargo.toml +++ b/third_party/rust/bincode/Cargo.toml @@ -1,20 +1,33 @@ +# THIS FILE IS AUTOMATICALLY GENERATED BY CARGO +# +# When uploading crates to the registry Cargo will automatically +# "normalize" Cargo.toml files for maximal compatibility +# with all versions of Cargo and also rewrite `path` dependencies +# to registry (e.g. crates.io) dependencies +# +# If you believe there's an error in this file please file an +# issue against the rust-lang/cargo repository. If you're +# editing this file be aware that the upstream Cargo.toml +# will likely look very different (and much more reasonable) + [package] name = "bincode" -version = "0.8.0" +version = "0.9.1" authors = ["Ty Overby ", "Francesco Mazzoli ", "David Tolnay ", "Daniel Griffen"] - -repository = "https://github.com/TyOverby/bincode" +exclude = ["./logo.png"] +publish = true +description = "A binary serialization / deserialization strategy that uses Serde for transforming structs into bytes and vice versa!" documentation = "https://docs.rs/bincode" keywords = ["binary", "encode", "decode", "serialize", "deserialize"] - license = "MIT" -description = "A binary serialization / deserialization strategy that uses Serde for transforming structs into bytes and vice versa!" +repository = "https://github.com/TyOverby/bincode" +[dependencies.byteorder] +version = "1.0.0" -[dependencies] -byteorder = "1.0.0" -num-traits = "0.1.32" -serde = "1.*.*" +[dependencies.serde] +version = "1.*.*" +[dev-dependencies.serde_bytes] +version = "0.10.*" -[dev-dependencies] -serde_bytes = "0.10.*" -serde_derive = "1.*.*" +[dev-dependencies.serde_derive] +version = "1.*.*" diff --git a/third_party/rust/bincode/examples/basic.rs b/third_party/rust/bincode/examples/basic.rs index 28c8b61bedfc..1632d75cc8dc 100644 --- a/third_party/rust/bincode/examples/basic.rs +++ b/third_party/rust/bincode/examples/basic.rs @@ -4,13 +4,13 @@ extern crate bincode; use bincode::{serialize, deserialize, Infinite}; -#[derive(Serialize, Deserialize, PartialEq)] +#[derive(Serialize, Deserialize, PartialEq, Debug)] struct Entity { x: f32, y: f32, } -#[derive(Serialize, Deserialize, PartialEq)] +#[derive(Serialize, Deserialize, PartialEq, Debug)] struct World(Vec); fn main() { @@ -18,10 +18,10 @@ fn main() { let encoded: Vec = serialize(&world, Infinite).unwrap(); - // 8 bytes for the length of the vector, 4 bytes per float. + // 8 bytes for the length of the vector (usize), 4 bytes per float. assert_eq!(encoded.len(), 8 + 4 * 4); let decoded: World = deserialize(&encoded[..]).unwrap(); - assert!(world == decoded); + assert_eq!(world, decoded); } diff --git a/third_party/rust/bincode/readme.md b/third_party/rust/bincode/readme.md index b37d43016533..cbfff19f04d4 100644 --- a/third_party/rust/bincode/readme.md +++ b/third_party/rust/bincode/readme.md @@ -10,13 +10,14 @@ A compact encoder / decoder pair that uses a binary zero-fluff encoding scheme. The size of the encoded object will be the same or smaller than the size that the object takes up in memory in a running Rust program. -In addition to exposing two simple functions that encode to Vec and decode -from Vec, binary-encode exposes a Reader/Writer API that makes it work +In addition to exposing two simple functions +(one that encodes to `Vec`, and one that decodes from `&[u8]`), +binary-encode exposes a Reader/Writer API that makes it work perfectly with other stream-based apis such as rust files, network streams, and the [flate2-rs](https://github.com/alexcrichton/flate2-rs) compression library. -## [Api Documentation](http://tyoverby.github.io/bincode/bincode/) +## [Api Documentation](http://docs.rs/bincode/) ## Bincode in the wild @@ -32,13 +33,13 @@ extern crate bincode; use bincode::{serialize, deserialize, Infinite}; -#[derive(Serialize, Deserialize, PartialEq)] +#[derive(Serialize, Deserialize, PartialEq, Debug)] struct Entity { x: f32, y: f32, } -#[derive(Serialize, Deserialize, PartialEq)] +#[derive(Serialize, Deserialize, PartialEq, Debug)] struct World(Vec); fn main() { @@ -51,7 +52,7 @@ fn main() { let decoded: World = deserialize(&encoded[..]).unwrap(); - assert!(world == decoded); + assert_eq!(world, decoded); } ``` @@ -67,7 +68,7 @@ then the contents. However, there are some implementation details to be aware of: * `isize`/`usize` are encoded as `i64`/`u64`, for portability. -* enums variants are encoded as a `u32` instead of a `uint`. +* enums variants are encoded as a `u32` instead of a `usize`. `u32` is enough for all practical uses. * `str` is encoded as `(u64, &[u8])`, where the `u64` is the number of bytes contained in the encoded string. diff --git a/third_party/rust/bincode/src/de/mod.rs b/third_party/rust/bincode/src/de/mod.rs index b98be7e4df75..0bb16679d456 100644 --- a/third_party/rust/bincode/src/de/mod.rs +++ b/third_party/rust/bincode/src/de/mod.rs @@ -56,11 +56,9 @@ impl<'de, R: BincodeRead<'de>, E: ByteOrder, S: SizeLimit> Deserializer } fn read_string(&mut self) -> Result { - String::from_utf8(try!(self.read_vec())).map_err(|err| - ErrorKind::InvalidEncoding{ - desc: "error while decoding utf8 string", - detail: Some(format!("Deserialize error: {}", err)) - }.into()) + let vec = self.read_vec()?; + String::from_utf8(vec).map_err(|e| + ErrorKind::InvalidUtf8Encoding(e.utf8_error()).into()) } } @@ -85,8 +83,7 @@ where R: BincodeRead<'de>, S: SizeLimit, E: ByteOrder { fn deserialize_any(self, _visitor: V) -> Result where V: serde::de::Visitor<'de>, { - let message = "bincode does not support Deserializer::deserialize"; - Err(Error::custom(message)) + Err(Box::new(ErrorKind::DeserializeAnyNotSupported)) } fn deserialize_bool(self, visitor: V) -> Result @@ -97,10 +94,7 @@ where R: BincodeRead<'de>, S: SizeLimit, E: ByteOrder { 1 => visitor.visit_bool(true), 0 => visitor.visit_bool(false), value => { - Err(ErrorKind::InvalidEncoding{ - desc: "invalid u8 when decoding bool", - detail: Some(format!("Expected 0 or 1, got {}", value)) - }.into()) + Err(ErrorKind::InvalidBoolEncoding(value).into()) } } } @@ -143,10 +137,7 @@ where R: BincodeRead<'de>, S: SizeLimit, E: ByteOrder { use std::str; let error = || { - ErrorKind::InvalidEncoding{ - desc: "Invalid char encoding", - detail: None, - }.into() + ErrorKind::InvalidCharEncoding.into() }; let mut buf = [0u8; 4]; @@ -256,10 +247,7 @@ where R: BincodeRead<'de>, S: SizeLimit, E: ByteOrder { match value { 0 => visitor.visit_none(), 1 => visitor.visit_some(&mut *self), - _ => Err(ErrorKind::InvalidEncoding{ - desc: "invalid tag when decoding Option", - detail: Some(format!("Expected 0 or 1, got {}", value)) - }.into()), + v => Err(ErrorKind::InvalidTagEncoding(v as usize).into()) } } diff --git a/third_party/rust/bincode/src/de/read.rs b/third_party/rust/bincode/src/de/read.rs index c22ee230643a..8ef0403f4ce6 100644 --- a/third_party/rust/bincode/src/de/read.rs +++ b/third_party/rust/bincode/src/de/read.rs @@ -1,10 +1,10 @@ -use std::io::{Read as IoRead, Result as IoResult, Error as IoError, ErrorKind as IoErrorKind}; +use std::io; use ::Result; use serde_crate as serde; /// A byte-oriented reading trait that is specialized for /// slices and generic readers. -pub trait BincodeRead<'storage>: IoRead { +pub trait BincodeRead<'storage>: io::Read + ::private::Sealed { #[doc(hidden)] fn forward_read_str(&mut self, length: usize, visitor: V) -> Result where V: serde::de::Visitor<'storage>; @@ -23,7 +23,7 @@ pub struct SliceReader<'storage> { } /// A BincodeRead implementation for io::Readers -pub struct IoReadReader { +pub struct IoReader { reader: R, temp_buffer: Vec, } @@ -37,31 +37,37 @@ impl <'storage> SliceReader<'storage> { } } -impl IoReadReader { +impl IoReader { /// Constructs an IoReadReader - pub fn new(r: R) -> IoReadReader { - IoReadReader { + pub fn new(r: R) -> IoReader { + IoReader { reader: r, temp_buffer: vec![], } } } -impl <'storage> IoRead for SliceReader<'storage> { - fn read(&mut self, out: & mut [u8]) -> IoResult { +impl <'storage> io::Read for SliceReader<'storage> { + fn read(&mut self, out: & mut [u8]) -> io::Result { (&mut self.slice).read(out) } + fn read_exact(&mut self, out: & mut [u8]) -> io::Result<()> { + (&mut self.slice).read_exact(out) + } } -impl IoRead for IoReadReader { - fn read(&mut self, out: & mut [u8]) -> IoResult { +impl io::Read for IoReader { + fn read(&mut self, out: & mut [u8]) -> io::Result { self.reader.read(out) } + fn read_exact(&mut self, out: & mut [u8]) -> io::Result<()> { + self.reader.read_exact(out) + } } impl <'storage> SliceReader<'storage> { fn unexpected_eof() -> Box<::ErrorKind> { - return Box::new(::ErrorKind::IoError(IoError::new(IoErrorKind::UnexpectedEof, ""))); + return Box::new(::ErrorKind::Io(io::Error::new(io::ErrorKind::UnexpectedEof, ""))); } } @@ -75,10 +81,7 @@ impl <'storage> BincodeRead<'storage> for SliceReader<'storage> { let string = match ::std::str::from_utf8(&self.slice[..length]) { Ok(s) => s, - Err(_) => return Err(Box::new(ErrorKind::InvalidEncoding { - desc: "string was not valid utf8", - detail: None, - })), + Err(e) => return Err(ErrorKind::InvalidUtf8Encoding(e).into()), }; let r = visitor.visit_borrowed_str(string); self.slice = &self.slice[length..]; @@ -107,7 +110,7 @@ impl <'storage> BincodeRead<'storage> for SliceReader<'storage> { } } -impl IoReadReader where R: IoRead { +impl IoReader where R: io::Read { fn fill_buffer(&mut self, length: usize) -> Result<()> { let current_length = self.temp_buffer.len(); if length > current_length{ @@ -120,17 +123,14 @@ impl IoReadReader where R: IoRead { } } -impl BincodeRead<'static> for IoReadReader where R: IoRead { +impl BincodeRead<'static> for IoReader where R: io::Read { fn forward_read_str(&mut self, length: usize, visitor: V) -> Result where V: serde::de::Visitor<'static> { self.fill_buffer(length)?; let string = match ::std::str::from_utf8(&self.temp_buffer[..length]) { Ok(s) => s, - Err(_) => return Err(Box::new(::ErrorKind::InvalidEncoding { - desc: "string was not valid utf8", - detail: None, - })), + Err(e) => return Err(::ErrorKind::InvalidUtf8Encoding(e).into()), }; let r = visitor.visit_str(string); diff --git a/third_party/rust/bincode/src/internal.rs b/third_party/rust/bincode/src/internal.rs index d8aa74e318a0..960a65cec7b6 100644 --- a/third_party/rust/bincode/src/internal.rs +++ b/third_party/rust/bincode/src/internal.rs @@ -2,11 +2,12 @@ //! that use the `serde` crate for the serializable and deserializable //! implementation. -use std::io::{Write, Read}; -use std::io::Error as IoError; +use std::io::{self, Write, Read}; use std::{error, fmt, result}; -use ::SizeLimit; +use std::str::Utf8Error; +use ::{CountSize, SizeLimit}; use byteorder::{ByteOrder}; +use std::error::Error as StdError; pub use super::de::{ Deserializer, @@ -24,9 +25,6 @@ use serde_crate as serde; pub type Result = result::Result; /// An error that can be produced during (de)serializing. -/// -/// If decoding from a Buffer, assume that the buffer has been left -/// in an invalid state. pub type Error = Box; /// The kind of error that can be produced during a serialization or deserialization. @@ -34,17 +32,20 @@ pub type Error = Box; pub enum ErrorKind { /// If the error stems from the reader/writer that is being used /// during (de)serialization, that error will be stored and returned here. - IoError(IoError), - /// If the bytes in the reader are not decodable because of an invalid - /// encoding, this error will be returned. This error is only possible - /// if a stream is corrupted. A stream produced from `encode` or `encode_into` - /// should **never** produce an InvalidEncoding error. - InvalidEncoding { - #[allow(missing_docs)] - desc: &'static str, - #[allow(missing_docs)] - detail: Option - }, + Io(io::Error), + /// Returned if the deserializer attempts to deserialize a string that is not valid utf8 + InvalidUtf8Encoding(Utf8Error), + /// Returned if the deserializer attempts to deserialize a bool that was + /// not encoded as either a 1 or a 0 + InvalidBoolEncoding(u8), + /// Returned if the deserializer attempts to deserialize a char that is not in the correct format. + InvalidCharEncoding, + /// Returned if the deserializer attempts to deserialize the tag of an enum that is + /// not in the expected ranges + InvalidTagEncoding(usize), + /// Serde has a deserialize_any method that lets the format hint to the + /// object which route to take in deserializing. + DeserializeAnyNotSupported, /// If (de)serializing a message takes more than the provided size limit, this /// error is returned. SizeLimit, @@ -54,12 +55,16 @@ pub enum ErrorKind { Custom(String) } -impl error::Error for ErrorKind { +impl StdError for ErrorKind { fn description(&self) -> &str { match *self { - ErrorKind::IoError(ref err) => error::Error::description(err), - ErrorKind::InvalidEncoding{desc, ..} => desc, + ErrorKind::Io(ref err) => error::Error::description(err), + ErrorKind::InvalidUtf8Encoding(_) => "string is not valid utf8", + ErrorKind::InvalidBoolEncoding(_) => "invalid u8 while decoding bool", + ErrorKind::InvalidCharEncoding => "char is not valid", + ErrorKind::InvalidTagEncoding(_) => "tag for enum is not valid", ErrorKind::SequenceMustHaveLength => "bincode can't encode infinite sequences", + ErrorKind::DeserializeAnyNotSupported => "bincode doesn't support serde::Deserializer::deserialize_any", ErrorKind::SizeLimit => "the size limit for decoding has been reached", ErrorKind::Custom(ref msg) => msg, @@ -68,34 +73,44 @@ impl error::Error for ErrorKind { fn cause(&self) -> Option<&error::Error> { match *self { - ErrorKind::IoError(ref err) => err.cause(), - ErrorKind::InvalidEncoding{..} => None, + ErrorKind::Io(ref err) => Some(err), + ErrorKind::InvalidUtf8Encoding(_) => None, + ErrorKind::InvalidBoolEncoding(_) => None, + ErrorKind::InvalidCharEncoding => None, + ErrorKind::InvalidTagEncoding(_) => None, ErrorKind::SequenceMustHaveLength => None, + ErrorKind::DeserializeAnyNotSupported => None, ErrorKind::SizeLimit => None, ErrorKind::Custom(_) => None, } } } -impl From for Error { - fn from(err: IoError) -> Error { - ErrorKind::IoError(err).into() +impl From for Error { + fn from(err: io::Error) -> Error { + ErrorKind::Io(err).into() } } impl fmt::Display for ErrorKind { fn fmt(&self, fmt: &mut fmt::Formatter) -> fmt::Result { match *self { - ErrorKind::IoError(ref ioerr) => - write!(fmt, "IoError: {}", ioerr), - ErrorKind::InvalidEncoding{desc, detail: None}=> - write!(fmt, "InvalidEncoding: {}", desc), - ErrorKind::InvalidEncoding{desc, detail: Some(ref detail)}=> - write!(fmt, "InvalidEncoding: {} ({})", desc, detail), + ErrorKind::Io(ref ioerr) => + write!(fmt, "io error: {}", ioerr), + ErrorKind::InvalidUtf8Encoding(ref e) => + write!(fmt, "{}: {}", self.description(), e), + ErrorKind::InvalidBoolEncoding(b) => + write!(fmt, "{}, expected 0 or 1, found {}", self.description(), b), + ErrorKind::InvalidCharEncoding => + write!(fmt, "{}", self.description()), + ErrorKind::InvalidTagEncoding(tag) => + write!(fmt, "{}, found {}", self.description(), tag), ErrorKind::SequenceMustHaveLength => - write!(fmt, "Bincode can only encode sequences and maps that have a knowable size ahead of time."), + write!(fmt, "bincode can only encode sequences and maps that have a knowable size ahead of time."), ErrorKind::SizeLimit => - write!(fmt, "SizeLimit"), + write!(fmt, "size limit was exceeded"), + ErrorKind::DeserializeAnyNotSupported=> + write!(fmt, "bincode does not support the serde::Deserializer::deserialize_any method"), ErrorKind::Custom(ref s) => s.fmt(fmt), } @@ -122,7 +137,7 @@ impl serde::ser::Error for Error { /// If this returns an `Error` (other than SizeLimit), assume that the /// writer is in an invalid state, as writing could bail out in the middle of /// serializing. -pub fn serialize_into(writer: &mut W, value: &T, size_limit: S) -> Result<()> +pub fn serialize_into(writer: W, value: &T, size_limit: S) -> Result<()> where W: Write, T: serde::Serialize, S: SizeLimit, E: ByteOrder { if let Some(limit) = size_limit.limit() { @@ -155,12 +170,6 @@ pub fn serialize(value: &T, size_limit: S) -> Result> Ok(writer) } - -struct CountSize { - total: u64, - limit: Option, -} - impl SizeLimit for CountSize { fn add(&mut self, c: u64) -> Result<()> { self.total += c; @@ -210,7 +219,7 @@ pub fn serialized_size_bounded(value: &T, max: u64) -> Option } } -/// Deserializes an object directly from a `Buffer`ed Reader. +/// Deserializes an object directly from a `Read`er. /// /// If the provided `SizeLimit` is reached, the deserialization will bail immediately. /// A SizeLimit can help prevent an attacker from flooding your server with @@ -219,10 +228,10 @@ pub fn serialized_size_bounded(value: &T, max: u64) -> Option /// If this returns an `Error`, assume that the buffer that you passed /// in is in an invalid state, as the error could be returned during any point /// in the reading. -pub fn deserialize_from(reader: &mut R, size_limit: S) -> Result +pub fn deserialize_from(reader: R, size_limit: S) -> Result where R: Read, T: serde::de::DeserializeOwned, S: SizeLimit, E: ByteOrder { - let reader = ::de::read::IoReadReader::new(reader); + let reader = ::de::read::IoReader::new(reader); let mut deserializer = Deserializer::<_, S, E>::new(reader, size_limit); serde::Deserialize::deserialize(&mut deserializer) } diff --git a/third_party/rust/bincode/src/lib.rs b/third_party/rust/bincode/src/lib.rs index f4d76813c45d..2c805ed61551 100644 --- a/third_party/rust/bincode/src/lib.rs +++ b/third_party/rust/bincode/src/lib.rs @@ -4,9 +4,9 @@ //! serialization strategy. //! //! There are simple functions for encoding to `Vec` and decoding from -//! `&[u8]`, but the meat of the library is the `encode_into` and `decode_from` -//! functions which respectively allow encoding into a `std::io::Writer` -//! and decoding from a `std::io::Buffer`. +//! `&[u8]`, but the meat of the library is the `serialize_into` and `deserialize_from` +//! functions which respectively allow encoding into any `std::io::Write` +//! or decode from any `std::io::Read`. //! //! ## Modules //! Until "default type parameters" lands, we have an extra module called `endian_choice` @@ -37,7 +37,6 @@ #![crate_type = "dylib"] extern crate byteorder; -extern crate num_traits; extern crate serde as serde_crate; mod ser; @@ -46,7 +45,7 @@ pub mod internal; pub mod read_types { //! The types that the deserializer uses for optimizations - pub use ::de::read::{SliceReader, BincodeRead, IoReadReader}; + pub use ::de::read::{SliceReader, BincodeRead, IoReader}; } use std::io::{Read, Write}; @@ -125,7 +124,7 @@ pub fn serialize(value: &T, size_limit: S) -> internal::Result Result<()>; @@ -143,6 +142,11 @@ pub struct Bounded(pub u64); #[derive(Copy, Clone)] pub struct Infinite; +struct CountSize { + total: u64, + limit: Option, +} + impl SizeLimit for Bounded { #[inline(always)] fn add(&mut self, n: u64) -> Result<()> { @@ -165,3 +169,13 @@ impl SizeLimit for Infinite { #[inline(always)] fn limit(&self) -> Option { None } } + +mod private { + pub trait Sealed {} + + impl<'a> Sealed for super::de::read::SliceReader<'a> {} + impl Sealed for super::de::read::IoReader {} + impl Sealed for super::Infinite {} + impl Sealed for super::Bounded {} + impl Sealed for super::CountSize {} +} diff --git a/third_party/rust/bincode/tests/test.rs b/third_party/rust/bincode/tests/test.rs index db0031b775fc..5299a01bfca0 100644 --- a/third_party/rust/bincode/tests/test.rs +++ b/third_party/rust/bincode/tests/test.rs @@ -195,25 +195,32 @@ fn test_fixed_size_array() { #[test] fn deserializing_errors() { - fn isize_invalid_deserialize(res: Result) { - match res.map_err(|e| *e) { - Err(ErrorKind::InvalidEncoding{..}) => {}, - Err(ErrorKind::Custom(ref s)) if s.contains("invalid encoding") => {}, - Err(ErrorKind::Custom(ref s)) if s.contains("invalid value") => {}, - other => panic!("Expecting InvalidEncoding, got {:?}", other), - } + + match *deserialize_little::(&vec![0xA][..]).unwrap_err() { + ErrorKind::InvalidBoolEncoding(0xA) => {}, + _ => panic!(), + } + match *deserialize_little::(&vec![1, 0, 0, 0, 0, 0, 0, 0, 0xFF][..]).unwrap_err() { + ErrorKind::InvalidUtf8Encoding(_) => {}, + _ => panic!(), } - isize_invalid_deserialize(deserialize_little::(&vec![0xA][..])); - isize_invalid_deserialize(deserialize_little::(&vec![1, 0, 0, 0, 0, 0, 0, 0, 0xFF][..])); // Out-of-bounds variant #[derive(Serialize, Deserialize, Debug)] enum Test { One, Two, }; - isize_invalid_deserialize(deserialize_little::(&vec![0, 0, 0, 5][..])); - isize_invalid_deserialize(deserialize_little::>(&vec![5, 0][..])); + + match *deserialize_little::(&vec![0, 0, 0, 5][..]).unwrap_err() { + // Error message comes from serde + ErrorKind::Custom(_) => {}, + _ => panic!(), + } + match *deserialize_little::>(&vec![5, 0][..]).unwrap_err() { + ErrorKind::InvalidTagEncoding(_) => {}, + _ => panic!(), + } } #[test] diff --git a/third_party/rust/gamma-lut/.cargo-checksum.json b/third_party/rust/gamma-lut/.cargo-checksum.json index 09f07abb36a2..5b653633005f 100644 --- a/third_party/rust/gamma-lut/.cargo-checksum.json +++ b/third_party/rust/gamma-lut/.cargo-checksum.json @@ -1 +1 @@ -{"files":{".cargo-ok":"e3b0c44298fc1c149afbf4c8996fb92427ae41e4649b934ca495991b7852b855",".travis.yml":"b1affa3cb943685d81ac6870109bf32bdcfef9602c6272041fe59002d08d6b94","Cargo.toml":"b3ffad2789ef4fe16007123118f53dacfb07c5e06eb0623b2e576875c58e6668","LICENSE":"3db78572e8657cca9e9446ce56a057b8a981eb41af318c49a5fe08e7a10fa52a","README.md":"33ad41b44d52e867b6cb385d1cdb5486dce70434a377ea41f6286218e7688f46","examples/basic.rs":"b8ed4dd909de2bceca7325f742e628a6007c38167d70d567bdc03188f14584a7","src/lib.rs":"62194a60c7ee0a1a84023230f92c15479fec3960fef207d62500b9c357938bfd"},"package":"41f72af1e933f296b827361eb9e70d0267abf8ad0de9ec7fa667bbe67177b297"} \ No newline at end of file +{"files":{".cargo-ok":"e3b0c44298fc1c149afbf4c8996fb92427ae41e4649b934ca495991b7852b855",".travis.yml":"b1affa3cb943685d81ac6870109bf32bdcfef9602c6272041fe59002d08d6b94","Cargo.toml":"c6b5872c64a03b359da62a4f554d79d9f4dc087588a4e95d1923c79fed49fa50","LICENSE":"3db78572e8657cca9e9446ce56a057b8a981eb41af318c49a5fe08e7a10fa52a","README.md":"33ad41b44d52e867b6cb385d1cdb5486dce70434a377ea41f6286218e7688f46","examples/basic.rs":"b8ed4dd909de2bceca7325f742e628a6007c38167d70d567bdc03188f14584a7","src/lib.rs":"48085fada087b63821d9f5d9dcedba9af7de744a9c077da29460d4e095ce9891"},"package":"dd65074503368cef99b98844012adfed8d7f99ff3e1e6d05e9055232f2d59dc9"} \ No newline at end of file diff --git a/third_party/rust/gamma-lut/Cargo.toml b/third_party/rust/gamma-lut/Cargo.toml index 66f84e7a4674..9368d354a66c 100644 --- a/third_party/rust/gamma-lut/Cargo.toml +++ b/third_party/rust/gamma-lut/Cargo.toml @@ -1,13 +1,24 @@ +# THIS FILE IS AUTOMATICALLY GENERATED BY CARGO +# +# When uploading crates to the registry Cargo will automatically +# "normalize" Cargo.toml files for maximal compatibility +# with all versions of Cargo and also rewrite `path` dependencies +# to registry (e.g. crates.io) dependencies +# +# If you believe there's an error in this file please file an +# issue against the rust-lang/cargo repository. If you're +# editing this file be aware that the upstream Cargo.toml +# will likely look very different (and much more reasonable) + [package] name = "gamma-lut" -version = "0.2.0" -authors = ["Mason Chang ", - "Dzmitry Malyshau "] +version = "0.2.1" +authors = ["Mason Chang ", "Dzmitry Malyshau "] description = "Rust port of Skia gamma correcting tables" +documentation = "https://docs.rs/gamma-lut" keywords = ["gamma"] license = "MPL-2.0" repository = "https://github.com/changm/gamma-lut-rs" -documentation = "https://docs.rs/gamma-lut" [lib] name = "gamma_lut" @@ -15,6 +26,5 @@ path = "src/lib.rs" [[example]] name = "basic" - -[dependencies] -log = "0.3" +[dependencies.log] +version = "0.3" diff --git a/third_party/rust/gamma-lut/src/lib.rs b/third_party/rust/gamma-lut/src/lib.rs index 302ef9f2082a..cfbe8637ed17 100644 --- a/third_party/rust/gamma-lut/src/lib.rs +++ b/third_party/rust/gamma-lut/src/lib.rs @@ -21,10 +21,12 @@ pub enum LuminanceColorSpace { impl LuminanceColorSpace { pub fn new(gamma: f32) -> LuminanceColorSpace { - match gamma { - 1.0 => LuminanceColorSpace::Linear, - 0.0 => LuminanceColorSpace::Srgb, - _ => LuminanceColorSpace::Gamma(gamma), + if gamma == 1.0 { + LuminanceColorSpace::Linear + } else if gamma == 0.0 { + LuminanceColorSpace::Srgb + } else { + LuminanceColorSpace::Gamma(gamma) } } @@ -331,7 +333,7 @@ impl GammaLut { pixel[0] = table_g[luminance as usize]; pixel[1] = table_g[luminance as usize]; pixel[2] = table_g[luminance as usize]; - // Don't touch alpha + pixel[3] = table_g[luminance as usize]; } } } diff --git a/toolkit/library/gtest/rust/Cargo.lock b/toolkit/library/gtest/rust/Cargo.lock index 652056cf87d1..8510b6189668 100644 --- a/toolkit/library/gtest/rust/Cargo.lock +++ b/toolkit/library/gtest/rust/Cargo.lock @@ -144,6 +144,15 @@ dependencies = [ "serde 1.0.8 (registry+https://github.com/rust-lang/crates.io-index)", ] +[[package]] +name = "bincode" +version = "0.9.1" +source = "registry+https://github.com/rust-lang/crates.io-index" +dependencies = [ + "byteorder 1.0.0 (registry+https://github.com/rust-lang/crates.io-index)", + "serde 1.0.8 (registry+https://github.com/rust-lang/crates.io-index)", +] + [[package]] name = "bindgen" version = "0.29.1" @@ -533,7 +542,7 @@ dependencies = [ [[package]] name = "gamma-lut" -version = "0.2.0" +version = "0.2.1" source = "registry+https://github.com/rust-lang/crates.io-index" dependencies = [ "log 0.3.8 (registry+https://github.com/rust-lang/crates.io-index)", @@ -1586,7 +1595,7 @@ name = "webrender" version = "0.52.1" dependencies = [ "app_units 0.5.6 (registry+https://github.com/rust-lang/crates.io-index)", - "bincode 0.8.0 (registry+https://github.com/rust-lang/crates.io-index)", + "bincode 0.9.1 (registry+https://github.com/rust-lang/crates.io-index)", "bitflags 0.9.1 (registry+https://github.com/rust-lang/crates.io-index)", "byteorder 1.0.0 (registry+https://github.com/rust-lang/crates.io-index)", "core-foundation 0.4.4 (registry+https://github.com/rust-lang/crates.io-index)", @@ -1596,7 +1605,7 @@ dependencies = [ "euclid 0.15.2 (registry+https://github.com/rust-lang/crates.io-index)", "freetype 0.3.0 (registry+https://github.com/rust-lang/crates.io-index)", "fxhash 0.2.1 (registry+https://github.com/rust-lang/crates.io-index)", - "gamma-lut 0.2.0 (registry+https://github.com/rust-lang/crates.io-index)", + "gamma-lut 0.2.1 (registry+https://github.com/rust-lang/crates.io-index)", "gleam 0.4.8 (registry+https://github.com/rust-lang/crates.io-index)", "lazy_static 0.2.8 (registry+https://github.com/rust-lang/crates.io-index)", "log 0.3.8 (registry+https://github.com/rust-lang/crates.io-index)", @@ -1613,7 +1622,7 @@ name = "webrender_api" version = "0.52.1" dependencies = [ "app_units 0.5.6 (registry+https://github.com/rust-lang/crates.io-index)", - "bincode 0.8.0 (registry+https://github.com/rust-lang/crates.io-index)", + "bincode 0.9.1 (registry+https://github.com/rust-lang/crates.io-index)", "bitflags 0.9.1 (registry+https://github.com/rust-lang/crates.io-index)", "byteorder 1.0.0 (registry+https://github.com/rust-lang/crates.io-index)", "core-foundation 0.4.4 (registry+https://github.com/rust-lang/crates.io-index)", @@ -1678,6 +1687,7 @@ dependencies = [ "checksum backtrace-sys 0.1.10 (registry+https://github.com/rust-lang/crates.io-index)" = "d192fd129132fbc97497c1f2ec2c2c5174e376b95f535199ef4fe0a293d33842" "checksum binary-space-partition 0.1.2 (registry+https://github.com/rust-lang/crates.io-index)" = "88ceb0d16c4fd0e42876e298d7d3ce3780dd9ebdcbe4199816a32c77e08597ff" "checksum bincode 0.8.0 (registry+https://github.com/rust-lang/crates.io-index)" = "e103c8b299b28a9c6990458b7013dc4a8356a9b854c51b9883241f5866fac36e" +"checksum bincode 0.9.1 (registry+https://github.com/rust-lang/crates.io-index)" = "9d3fb369af639822830328794eba2501b3479652fcd021b2aeb1ed4984202afd" "checksum bindgen 0.29.1 (registry+https://github.com/rust-lang/crates.io-index)" = "ba610cba0c1727ed837316540068b51349b8268c073906067b7c3948598929bd" "checksum bitflags 0.7.0 (registry+https://github.com/rust-lang/crates.io-index)" = "aad18937a628ec6abcd26d1489012cc0e18c21798210f491af69ded9b881106d" "checksum bitflags 0.8.2 (registry+https://github.com/rust-lang/crates.io-index)" = "1370e9fc2a6ae53aea8b7a5110edbd08836ed87c88736dfabccade1c2b44bff4" @@ -1716,7 +1726,7 @@ dependencies = [ "checksum fs2 0.4.2 (registry+https://github.com/rust-lang/crates.io-index)" = "9ab76cfd2aaa59b7bf6688ad9ba15bbae64bff97f04ea02144cfd3443e5c2866" "checksum futures 0.1.13 (registry+https://github.com/rust-lang/crates.io-index)" = "55f0008e13fc853f79ea8fc86e931486860d4c4c156cdffb59fa5f7fa833660a" "checksum fxhash 0.2.1 (registry+https://github.com/rust-lang/crates.io-index)" = "c31b6d751ae2c7f11320402d34e41349dd1016f8d5d45e48c4312bc8625af50c" -"checksum gamma-lut 0.2.0 (registry+https://github.com/rust-lang/crates.io-index)" = "41f72af1e933f296b827361eb9e70d0267abf8ad0de9ec7fa667bbe67177b297" +"checksum gamma-lut 0.2.1 (registry+https://github.com/rust-lang/crates.io-index)" = "dd65074503368cef99b98844012adfed8d7f99ff3e1e6d05e9055232f2d59dc9" "checksum gcc 0.3.51 (registry+https://github.com/rust-lang/crates.io-index)" = "120d07f202dcc3f72859422563522b66fe6463a4c513df062874daad05f85f0a" "checksum gdi32-sys 0.2.0 (registry+https://github.com/rust-lang/crates.io-index)" = "0912515a8ff24ba900422ecda800b52f4016a56251922d397c576bf92c690518" "checksum gl_generator 0.5.3 (registry+https://github.com/rust-lang/crates.io-index)" = "0940975a4ca12b088d32b5d5134826c47d2e73de4b0b459b05244c01503eccbb" diff --git a/toolkit/library/rust/Cargo.lock b/toolkit/library/rust/Cargo.lock index 862e10e24a04..b4a11da3b2b5 100644 --- a/toolkit/library/rust/Cargo.lock +++ b/toolkit/library/rust/Cargo.lock @@ -143,6 +143,15 @@ dependencies = [ "serde 1.0.8 (registry+https://github.com/rust-lang/crates.io-index)", ] +[[package]] +name = "bincode" +version = "0.9.1" +source = "registry+https://github.com/rust-lang/crates.io-index" +dependencies = [ + "byteorder 1.0.0 (registry+https://github.com/rust-lang/crates.io-index)", + "serde 1.0.8 (registry+https://github.com/rust-lang/crates.io-index)", +] + [[package]] name = "bindgen" version = "0.29.1" @@ -532,7 +541,7 @@ dependencies = [ [[package]] name = "gamma-lut" -version = "0.2.0" +version = "0.2.1" source = "registry+https://github.com/rust-lang/crates.io-index" dependencies = [ "log 0.3.8 (registry+https://github.com/rust-lang/crates.io-index)", @@ -1598,7 +1607,7 @@ name = "webrender" version = "0.52.1" dependencies = [ "app_units 0.5.6 (registry+https://github.com/rust-lang/crates.io-index)", - "bincode 0.8.0 (registry+https://github.com/rust-lang/crates.io-index)", + "bincode 0.9.1 (registry+https://github.com/rust-lang/crates.io-index)", "bitflags 0.9.1 (registry+https://github.com/rust-lang/crates.io-index)", "byteorder 1.0.0 (registry+https://github.com/rust-lang/crates.io-index)", "core-foundation 0.4.4 (registry+https://github.com/rust-lang/crates.io-index)", @@ -1608,7 +1617,7 @@ dependencies = [ "euclid 0.15.2 (registry+https://github.com/rust-lang/crates.io-index)", "freetype 0.3.0 (registry+https://github.com/rust-lang/crates.io-index)", "fxhash 0.2.1 (registry+https://github.com/rust-lang/crates.io-index)", - "gamma-lut 0.2.0 (registry+https://github.com/rust-lang/crates.io-index)", + "gamma-lut 0.2.1 (registry+https://github.com/rust-lang/crates.io-index)", "gleam 0.4.8 (registry+https://github.com/rust-lang/crates.io-index)", "lazy_static 0.2.8 (registry+https://github.com/rust-lang/crates.io-index)", "log 0.3.8 (registry+https://github.com/rust-lang/crates.io-index)", @@ -1625,7 +1634,7 @@ name = "webrender_api" version = "0.52.1" dependencies = [ "app_units 0.5.6 (registry+https://github.com/rust-lang/crates.io-index)", - "bincode 0.8.0 (registry+https://github.com/rust-lang/crates.io-index)", + "bincode 0.9.1 (registry+https://github.com/rust-lang/crates.io-index)", "bitflags 0.9.1 (registry+https://github.com/rust-lang/crates.io-index)", "byteorder 1.0.0 (registry+https://github.com/rust-lang/crates.io-index)", "core-foundation 0.4.4 (registry+https://github.com/rust-lang/crates.io-index)", @@ -1690,6 +1699,7 @@ dependencies = [ "checksum backtrace-sys 0.1.10 (registry+https://github.com/rust-lang/crates.io-index)" = "d192fd129132fbc97497c1f2ec2c2c5174e376b95f535199ef4fe0a293d33842" "checksum binary-space-partition 0.1.2 (registry+https://github.com/rust-lang/crates.io-index)" = "88ceb0d16c4fd0e42876e298d7d3ce3780dd9ebdcbe4199816a32c77e08597ff" "checksum bincode 0.8.0 (registry+https://github.com/rust-lang/crates.io-index)" = "e103c8b299b28a9c6990458b7013dc4a8356a9b854c51b9883241f5866fac36e" +"checksum bincode 0.9.1 (registry+https://github.com/rust-lang/crates.io-index)" = "9d3fb369af639822830328794eba2501b3479652fcd021b2aeb1ed4984202afd" "checksum bindgen 0.29.1 (registry+https://github.com/rust-lang/crates.io-index)" = "ba610cba0c1727ed837316540068b51349b8268c073906067b7c3948598929bd" "checksum bitflags 0.7.0 (registry+https://github.com/rust-lang/crates.io-index)" = "aad18937a628ec6abcd26d1489012cc0e18c21798210f491af69ded9b881106d" "checksum bitflags 0.8.2 (registry+https://github.com/rust-lang/crates.io-index)" = "1370e9fc2a6ae53aea8b7a5110edbd08836ed87c88736dfabccade1c2b44bff4" @@ -1728,7 +1738,7 @@ dependencies = [ "checksum fs2 0.4.2 (registry+https://github.com/rust-lang/crates.io-index)" = "9ab76cfd2aaa59b7bf6688ad9ba15bbae64bff97f04ea02144cfd3443e5c2866" "checksum futures 0.1.13 (registry+https://github.com/rust-lang/crates.io-index)" = "55f0008e13fc853f79ea8fc86e931486860d4c4c156cdffb59fa5f7fa833660a" "checksum fxhash 0.2.1 (registry+https://github.com/rust-lang/crates.io-index)" = "c31b6d751ae2c7f11320402d34e41349dd1016f8d5d45e48c4312bc8625af50c" -"checksum gamma-lut 0.2.0 (registry+https://github.com/rust-lang/crates.io-index)" = "41f72af1e933f296b827361eb9e70d0267abf8ad0de9ec7fa667bbe67177b297" +"checksum gamma-lut 0.2.1 (registry+https://github.com/rust-lang/crates.io-index)" = "dd65074503368cef99b98844012adfed8d7f99ff3e1e6d05e9055232f2d59dc9" "checksum gcc 0.3.51 (registry+https://github.com/rust-lang/crates.io-index)" = "120d07f202dcc3f72859422563522b66fe6463a4c513df062874daad05f85f0a" "checksum gdi32-sys 0.2.0 (registry+https://github.com/rust-lang/crates.io-index)" = "0912515a8ff24ba900422ecda800b52f4016a56251922d397c576bf92c690518" "checksum gl_generator 0.5.3 (registry+https://github.com/rust-lang/crates.io-index)" = "0940975a4ca12b088d32b5d5134826c47d2e73de4b0b459b05244c01503eccbb"