From e3837055d71b287dfb629c3ac331fbe4b2e343b4 Mon Sep 17 00:00:00 2001 From: Ty Overby Date: Mon, 18 May 2015 23:27:07 -0700 Subject: [PATCH] Removes the "bytes read" return part from `decode` This reverts commit 5fa0c2bd8afca94061e1bb6d3d3e956da0dd331c. Conflicts: Cargo.toml --- examples/basic.rs | 2 +- src/lib.rs | 23 ++++++++--------------- src/reader.rs | 1 + src/test.rs | 28 ++++++++++++++-------------- 4 files changed, 24 insertions(+), 30 deletions(-) diff --git a/examples/basic.rs b/examples/basic.rs index f7f7eec..66972cb 100644 --- a/examples/basic.rs +++ b/examples/basic.rs @@ -24,7 +24,7 @@ fn main() { // 8 bytes for the length of the vector, 4 bytes per float. assert_eq!(encoded.len(), 8 + 4 * 4); - let (decoded, _): (World, _) = bincode::decode(&encoded[..]).unwrap(); + let decoded: World = bincode::decode(&encoded[..]).unwrap(); assert!(world == decoded); } diff --git a/src/lib.rs b/src/lib.rs index 709e075..d5a9a5e 100644 --- a/src/lib.rs +++ b/src/lib.rs @@ -17,8 +17,8 @@ //! // The maximum size of the encoded message. //! let limit = bincode::SizeLimit::Bounded(20); //! -//! let encoded: Vec = bincode::encode(&target, limit).unwrap(); -//! let (decoded, len): (Option, u64) = bincode::decode(&encoded[..]).unwrap(); +//! let encoded: Vec = bincode::encode(&target, limit).unwrap(); +//! let decoded: Option = bincode::decode(&encoded[..]).unwrap(); //! assert_eq!(target, decoded); //! } //! ``` @@ -95,12 +95,9 @@ pub fn encode(t: &T, size_limit: SizeLimit) -> EncodingResult(b: &[u8]) -> DecodingResult<(T, u64)> { +/// 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 decode(b: &[u8]) -> DecodingResult { let mut b = b; decode_from(&mut b, SizeLimit::Infinite) } @@ -128,8 +125,7 @@ pub fn encode_into(t: &T, t.encode(&mut writer::EncoderWriter::new(w)) } -/// Decodes an object directly from a `Read`er. If successful, returns the -/// decoded object and the number of bytes read out of the `Read`er. +/// Decoes an object directly from a `Buffer`ed Reader. /// /// If the provided `SizeLimit` is reached, the decode will bail immediately. /// A SizeLimit can help prevent an attacker from flooding your server with @@ -138,11 +134,8 @@ pub fn encode_into(t: &T, /// If this returns an `DecodingError`, 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 decode_from(r: &mut R, size_limit: SizeLimit) -> DecodingResult<(T, u64)> { - let mut decoder_reader = reader::DecoderReader::new(r, size_limit); - let value = try!(Decodable::decode(&mut decoder_reader)); - let bytes_read = decoder_reader.bytes_read(); - Ok((value, bytes_read)) +pub fn decode_from(r: &mut R, size_limit: SizeLimit) -> DecodingResult { + Decodable::decode(&mut reader::DecoderReader::new(r, size_limit)) } diff --git a/src/reader.rs b/src/reader.rs index 52d4e9c..e32ff94 100644 --- a/src/reader.rs +++ b/src/reader.rs @@ -115,6 +115,7 @@ impl<'a, R: Read> DecoderReader<'a, R> { } } + /// Returns the number of bytes read from the contained Reader. pub fn bytes_read(&self) -> u64 { self.read } diff --git a/src/test.rs b/src/test.rs index 449eded..67e7be9 100644 --- a/src/test.rs +++ b/src/test.rs @@ -29,14 +29,14 @@ fn the_same(element: V) let rf = RefBox::new(v); let encoded = encode(&rf, Infinite).unwrap(); - let (decoded, _): (RefBox<'static, V>, _) = decode(&encoded[..]).unwrap(); + let decoded: RefBox<'static, V> = decode(&encoded[..]).unwrap(); decoded.take().deref() == v } let size = encoded_size(&element); let encoded = encode(&element, Infinite).unwrap(); - let (decoded, _) = decode(&encoded[..]).unwrap(); + let decoded = decode(&encoded[..]).unwrap(); assert!(element == decoded); assert!(size == encoded.len() as u64); assert!(ref_box_correct(&element)) @@ -215,12 +215,12 @@ fn decoding_errors() { fn too_big_decode() { let encoded = vec![0,0,0,3]; let mut encoded_ref = &encoded[..]; - let decoded: Result<(u32, _), _> = decode_from(&mut encoded_ref, Bounded(3)); + let decoded: Result = decode_from(&mut encoded_ref, Bounded(3)); assert!(decoded.is_err()); let encoded = vec![0,0,0,3]; let mut encoded_ref = &encoded[..]; - let decoded: Result<(u32, _), _> = decode_from(&mut encoded_ref, Bounded(4)); + let decoded: Result = decode_from(&mut encoded_ref, Bounded(4)); assert!(decoded.is_ok()); } @@ -228,9 +228,9 @@ fn too_big_decode() { fn too_big_char_decode() { let encoded = vec![0x41]; let mut encoded_ref = &encoded[..]; - let decoded: Result<(char, _), _> = decode_from(&mut encoded_ref, Bounded(1)); + let decoded: Result = decode_from(&mut encoded_ref, Bounded(1)); assert!(decoded.is_ok()); - assert_eq!(decoded.unwrap().0, 'A'); + assert_eq!(decoded.unwrap(), 'A'); } #[test] @@ -277,9 +277,9 @@ fn test_refbox() { // Test 1 { let encoded = encode(&Message::M1(RefBox::new(&large_object)), Infinite).unwrap(); - let decoded: (Message<'static>, _) = decode(&encoded[..]).unwrap(); + let decoded: Message<'static> = decode(&encoded[..]).unwrap(); - match decoded.0 { + match decoded { Message::M1(b) => assert!(b.take().deref() == &large_object), _ => assert!(false) } @@ -288,9 +288,9 @@ fn test_refbox() { // Test 2 { let encoded = encode(&Message::M2(RefBox::new(&large_map)), Infinite).unwrap(); - let decoded: (Message<'static>, _) = decode(&encoded[..]).unwrap(); + let decoded: Message<'static> = decode(&encoded[..]).unwrap(); - match decoded.0 { + match decoded { Message::M2(b) => assert!(b.take().deref() == &large_map), _ => assert!(false) } @@ -301,8 +301,8 @@ fn test_refbox() { fn test_strbox() { let strx: &'static str = "hello world"; let encoded = encode(&StrBox::new(strx), Infinite).unwrap(); - let decoded: (StrBox<'static>, _) = decode(&encoded[..]).unwrap(); - let stringx: String = decoded.0.take(); + let decoded: StrBox<'static> = decode(&encoded[..]).unwrap(); + let stringx: String = decoded.take(); assert!(strx == &stringx[..]); } @@ -310,8 +310,8 @@ fn test_strbox() { fn test_slicebox() { let slice = [1u32, 2, 3 ,4, 5]; let encoded = encode(&SliceBox::new(&slice), Infinite).unwrap(); - let decoded: (SliceBox<'static, u32>, _) = decode(&encoded[..]).unwrap(); - let vecx: Vec = decoded.0.take(); + let decoded: SliceBox<'static, u32> = decode(&encoded[..]).unwrap(); + let vecx: Vec = decoded.take(); assert!(slice == &vecx[..]); }