From 22a5fb8d9b760c5e08a008a77e0fb75623a2aec9 Mon Sep 17 00:00:00 2001 From: Carl Lerche Date: Tue, 28 Feb 2017 12:10:41 -0800 Subject: [PATCH] Rename some functions on Bytes --- src/bytes.rs | 44 +++++++++++++++++++++++++++++++------------- tests/test_bytes.rs | 30 +++++++++++++++--------------- 2 files changed, 46 insertions(+), 28 deletions(-) diff --git a/src/bytes.rs b/src/bytes.rs index d830b97..980e846 100644 --- a/src/bytes.rs +++ b/src/bytes.rs @@ -25,7 +25,7 @@ use std::sync::atomic::Ordering::{Relaxed, Acquire, Release, AcqRel}; /// /// assert_eq!(&a[..], b"Hello"); /// -/// let b = mem.drain_to(6); +/// let b = mem.split_to(6); /// /// assert_eq!(&mem[..], b"world"); /// assert_eq!(&b[..], b"Hello "); @@ -161,7 +161,7 @@ pub struct BytesMut { // `Arc>` requires two allocations, so if the buffer ends up never being // shared, that allocation is avoided. // -// When sharing does become necessary (`clone`, `drain_to`, `split_off`), that +// When sharing does become necessary (`clone`, `split_to`, `split_off`), that // is when the buffer is promoted to being shareable. The `Vec` is moved // into an `Arc` and both the original handle and the new handle use the same // buffer via the `Arc`. @@ -563,7 +563,7 @@ impl Bytes { /// use bytes::Bytes; /// /// let mut a = Bytes::from(&b"hello world"[..]); - /// let b = a.drain_to(5); + /// let b = a.split_to(5); /// /// assert_eq!(&a[..], b" world"); /// assert_eq!(&b[..], b"hello"); @@ -572,14 +572,20 @@ impl Bytes { /// # Panics /// /// Panics if `at > len` - pub fn drain_to(&mut self, at: usize) -> Bytes { + pub fn split_to(&mut self, at: usize) -> Bytes { Bytes { inner: Inner2 { - inner: self.inner.drain_to(at), + inner: self.inner.split_to(at), } } } + #[deprecated(since = "0.4.1", note = "use split_to instead")] + #[doc(hidden)] + pub fn drain_to(&mut self, at: usize) -> Bytes { + self.split_to(at) + } + /// Attempt to convert into a `BytesMut` handle. /// /// This will only succeed if there are no other outstanding references to @@ -889,7 +895,7 @@ impl BytesMut { /// /// Afterwards, `self` will be empty, but will retain any additional /// capacity that it had before the operation. This is identical to - /// `self.drain_to(self.len())`. + /// `self.split_to(self.len())`. /// /// This is an `O(1)` operation that just increases the reference count and /// sets a few indexes. @@ -902,16 +908,22 @@ impl BytesMut { /// let mut buf = BytesMut::with_capacity(1024); /// buf.put(&b"hello world"[..]); /// - /// let other = buf.drain(); + /// let other = buf.take(); /// /// assert!(buf.is_empty()); /// assert_eq!(1013, buf.capacity()); /// /// assert_eq!(other, b"hello world"[..]); /// ``` - pub fn drain(&mut self) -> BytesMut { + pub fn take(&mut self) -> BytesMut { let len = self.len(); - self.drain_to(len) + self.split_to(len) + } + + #[deprecated(since = "0.4.1", note = "use take instead")] + #[doc(hidden)] + pub fn drain(&mut self) -> BytesMut { + self.take() } /// Splits the buffer into two at the given index. @@ -928,7 +940,7 @@ impl BytesMut { /// use bytes::BytesMut; /// /// let mut a = BytesMut::from(&b"hello world"[..]); - /// let mut b = a.drain_to(5); + /// let mut b = a.split_to(5); /// /// a[0] = b'!'; /// b[0] = b'j'; @@ -940,14 +952,20 @@ impl BytesMut { /// # Panics /// /// Panics if `at > len` - pub fn drain_to(&mut self, at: usize) -> BytesMut { + pub fn split_to(&mut self, at: usize) -> BytesMut { BytesMut { inner: Inner2 { - inner: self.inner.drain_to(at), + inner: self.inner.split_to(at), } } } + #[deprecated(since = "0.4.1", note = "use split_to instead")] + #[doc(hidden)] + pub fn drain_to(&mut self, at: usize) -> BytesMut { + self.split_to(at) + } + /// Shortens the buffer, keeping the first `len` bytes and dropping the /// rest. /// @@ -1382,7 +1400,7 @@ impl Inner { return other } - fn drain_to(&mut self, at: usize) -> Inner { + fn split_to(&mut self, at: usize) -> Inner { let mut other = self.shallow_clone(); unsafe { diff --git a/tests/test_bytes.rs b/tests/test_bytes.rs index 2343fea..089b04b 100644 --- a/tests/test_bytes.rs +++ b/tests/test_bytes.rs @@ -135,34 +135,34 @@ fn split_off_uninitialized() { } #[test] -fn drain_to_1() { +fn split_to_1() { // Inline let mut a = Bytes::from(SHORT); - let b = a.drain_to(4); + let b = a.split_to(4); assert_eq!(SHORT[4..], a); assert_eq!(SHORT[..4], b); // Allocated let mut a = Bytes::from(LONG); - let b = a.drain_to(4); + let b = a.split_to(4); assert_eq!(LONG[4..], a); assert_eq!(LONG[..4], b); let mut a = Bytes::from(LONG); - let b = a.drain_to(30); + let b = a.split_to(30); assert_eq!(LONG[30..], a); assert_eq!(LONG[..30], b); } #[test] -fn drain_to_2() { +fn split_to_2() { let mut a = Bytes::from(LONG); assert_eq!(LONG, a); - let b = a.drain_to(1); + let b = a.split_to(1); assert_eq!(LONG[1..], a); drop(b); @@ -170,22 +170,22 @@ fn drain_to_2() { #[test] #[should_panic] -fn drain_to_oob() { +fn split_to_oob() { let mut hello = Bytes::from(&b"helloworld"[..]); - hello.drain_to(inline_cap() + 1); + hello.split_to(inline_cap() + 1); } #[test] #[should_panic] -fn drain_to_oob_mut() { +fn split_to_oob_mut() { let mut hello = BytesMut::from(&b"helloworld"[..]); - hello.drain_to(inline_cap() + 1); + hello.split_to(inline_cap() + 1); } #[test] -fn drain_to_uninitialized() { +fn split_to_uninitialized() { let mut bytes = BytesMut::with_capacity(1024); - let other = bytes.drain_to(128); + let other = bytes.split_to(128); assert_eq!(bytes.len(), 0); assert_eq!(bytes.capacity(), 896); @@ -219,7 +219,7 @@ fn reserve_convert() { let mut bytes = BytesMut::with_capacity(inline_cap()); bytes.put("abcdefghijkl"); - let a = bytes.drain_to(10); + let a = bytes.split_to(10); bytes.reserve(inline_cap() - 3); assert_eq!(inline_cap(), bytes.capacity()); @@ -233,7 +233,7 @@ fn reserve_convert() { // Arc -> Vec let mut bytes = BytesMut::from(LONG); - let a = bytes.drain_to(30); + let a = bytes.split_to(30); bytes.reserve(128); assert_eq!(bytes.capacity(), (bytes.len() + 128).next_power_of_two()); @@ -245,7 +245,7 @@ fn reserve_convert() { fn reserve_growth() { let mut bytes = BytesMut::with_capacity(64); bytes.put("hello world"); - let _ = bytes.drain(); + let _ = bytes.take(); bytes.reserve(65); assert_eq!(bytes.capacity(), 128);