tokio-rs/bytes
1
0
Fork 0
mirror of https://github.com/tokio-rs/bytes.git synced 2026-08-27 00:00:17 +02:00
Code Issues Packages Projects Releases Wiki Activity

Rename Buf/BufMut, methods to chunk/chunk_mut (#450)

Browse Source 
The `bytes()` / `bytes_mut()` name implies the method returns the full
set of bytes represented by `Buf`/`BufMut`. To rectify this, the methods
are renamed to `chunk()` and `chunk_mut()` to reflect the partial nature
of the returned byte slice.

`bytes_vectored()` is renamed `chunks_vectored()`.

Closes #447
This commit is contained in:
Carl Lerche
2020-12-18 11:04:31 -08:00
committed by GitHub
parent 54f5ced6c5
commit 06907f3e7b
18 changed files with 96 additions and 95 deletions
Download Patch File Download Diff File Expand all files Collapse all files
.github/workflows/ci.yml
+2 -1
View File
@@ -11,6 +11,7 @@ on:
env: env:
RUSTFLAGS: -Dwarnings RUSTFLAGS: -Dwarnings
RUST_BACKTRACE: 1 RUST_BACKTRACE: 1
nightly: nightly-2020-12-17
defaults: defaults:
run: run:
@@ -120,7 +121,7 @@ jobs:
steps: steps:
- uses: actions/checkout@v2 - uses: actions/checkout@v2
- name: Install Rust - name: Install Rust
run: rustup update nightly && rustup default nightly run: rustup update $nightly && rustup default $nightly
- name: Install rust-src - name: Install rust-src
run: rustup component add rust-src run: rustup component add rust-src
- name: ASAN / TSAN - name: ASAN / TSAN
benches/buf.rs
+3 -3
View File
@@ -53,7 +53,7 @@ impl Buf for TestBuf {
assert!(self.pos <= self.buf.len()); assert!(self.pos <= self.buf.len());
self.next_readlen(); self.next_readlen();
} }
fn bytes(&self) -> &[u8] { fn chunk(&self) -> &[u8] {
if self.readlen == 0 { if self.readlen == 0 {
Default::default() Default::default()
} else { } else {
@@ -87,8 +87,8 @@ impl Buf for TestBufC {
self.inner.advance(cnt) self.inner.advance(cnt)
} }
#[inline(never)] #[inline(never)]
fn bytes(&self) -> &[u8] { fn chunk(&self) -> &[u8] {
self.inner.bytes() self.inner.chunk()
} }
} }
src/buf/buf_impl.rs
+24 -24
View File
@@ -16,7 +16,7 @@ macro_rules! buf_get_impl {
// this Option<ret> trick is to avoid keeping a borrow on self // this Option<ret> trick is to avoid keeping a borrow on self
// when advance() is called (mut borrow) and to call bytes() only once // when advance() is called (mut borrow) and to call bytes() only once
let ret = $this let ret = $this
.bytes() .chunk()
.get(..SIZE) .get(..SIZE)
.map(|src| unsafe { $typ::$conv(*(src as *const _ as *const [_; SIZE])) }); .map(|src| unsafe { $typ::$conv(*(src as *const _ as *const [_; SIZE])) });
@@ -78,7 +78,7 @@ pub trait Buf {
/// the buffer. /// the buffer.
/// ///
/// This value is greater than or equal to the length of the slice returned /// This value is greater than or equal to the length of the slice returned
/// by `bytes`. /// by `chunk()`.
/// ///
/// # Examples /// # Examples
/// ///
@@ -115,31 +115,31 @@ pub trait Buf {
/// ///
/// let mut buf = &b"hello world"[..]; /// let mut buf = &b"hello world"[..];
/// ///
/// assert_eq!(buf.bytes(), &b"hello world"[..]); /// assert_eq!(buf.chunk(), &b"hello world"[..]);
/// ///
/// buf.advance(6); /// buf.advance(6);
/// ///
/// assert_eq!(buf.bytes(), &b"world"[..]); /// assert_eq!(buf.chunk(), &b"world"[..]);
/// ``` /// ```
/// ///
/// # Implementer notes /// # Implementer notes
/// ///
/// This function should never panic. Once the end of the buffer is reached, /// This function should never panic. Once the end of the buffer is reached,
/// i.e., `Buf::remaining` returns 0, calls to `bytes` should return an /// i.e., `Buf::remaining` returns 0, calls to `chunk()` should return an
/// empty slice. /// empty slice.
fn bytes(&self) -> &[u8]; fn chunk(&self) -> &[u8];
/// Fills `dst` with potentially multiple slices starting at `self`'s /// Fills `dst` with potentially multiple slices starting at `self`'s
/// current position. /// current position.
/// ///
/// If the `Buf` is backed by disjoint slices of bytes, `bytes_vectored` enables /// If the `Buf` is backed by disjoint slices of bytes, `chunk_vectored` enables
/// fetching more than one slice at once. `dst` is a slice of `IoSlice` /// fetching more than one slice at once. `dst` is a slice of `IoSlice`
/// references, enabling the slice to be directly used with [`writev`] /// references, enabling the slice to be directly used with [`writev`]
/// without any further conversion. The sum of the lengths of all the /// without any further conversion. The sum of the lengths of all the
/// buffers in `dst` will be less than or equal to `Buf::remaining()`. /// buffers in `dst` will be less than or equal to `Buf::remaining()`.
/// ///
/// The entries in `dst` will be overwritten, but the data **contained** by /// The entries in `dst` will be overwritten, but the data **contained** by
/// the slices **will not** be modified. If `bytes_vectored` does not fill every /// the slices **will not** be modified. If `chunk_vectored` does not fill every
/// entry in `dst`, then `dst` is guaranteed to contain all remaining slices /// entry in `dst`, then `dst` is guaranteed to contain all remaining slices
/// in `self. /// in `self.
/// ///
@@ -149,7 +149,7 @@ pub trait Buf {
/// # Implementer notes /// # Implementer notes
/// ///
/// This function should never panic. Once the end of the buffer is reached, /// This function should never panic. Once the end of the buffer is reached,
/// i.e., `Buf::remaining` returns 0, calls to `bytes_vectored` must return 0 /// i.e., `Buf::remaining` returns 0, calls to `chunk_vectored` must return 0
/// without mutating `dst`. /// without mutating `dst`.
/// ///
/// Implementations should also take care to properly handle being called /// Implementations should also take care to properly handle being called
@@ -157,13 +157,13 @@ pub trait Buf {
/// ///
/// [`writev`]: http://man7.org/linux/man-pages/man2/readv.2.html /// [`writev`]: http://man7.org/linux/man-pages/man2/readv.2.html
#[cfg(feature = "std")] #[cfg(feature = "std")]
fn bytes_vectored<'a>(&'a self, dst: &mut [IoSlice<'a>]) -> usize { fn chunks_vectored<'a>(&'a self, dst: &mut [IoSlice<'a>]) -> usize {
if dst.is_empty() { if dst.is_empty() {
return 0; return 0;
} }
if self.has_remaining() { if self.has_remaining() {
dst[0] = IoSlice::new(self.bytes()); dst[0] = IoSlice::new(self.chunk());
1 1
} else { } else {
0 0
@@ -172,7 +172,7 @@ pub trait Buf {
/// Advance the internal cursor of the Buf /// Advance the internal cursor of the Buf
/// ///
/// The next call to `bytes` will return a slice starting `cnt` bytes /// The next call to `chunk()` will return a slice starting `cnt` bytes
/// further into the underlying buffer. /// further into the underlying buffer.
/// ///
/// # Examples /// # Examples
@@ -182,11 +182,11 @@ pub trait Buf {
/// ///
/// let mut buf = &b"hello world"[..]; /// let mut buf = &b"hello world"[..];
/// ///
/// assert_eq!(buf.bytes(), &b"hello world"[..]); /// assert_eq!(buf.chunk(), &b"hello world"[..]);
/// ///
/// buf.advance(6); /// buf.advance(6);
/// ///
/// assert_eq!(buf.bytes(), &b"world"[..]); /// assert_eq!(buf.chunk(), &b"world"[..]);
/// ``` /// ```
/// ///
/// # Panics /// # Panics
@@ -253,7 +253,7 @@ pub trait Buf {
let cnt; let cnt;
unsafe { unsafe {
let src = self.bytes(); let src = self.chunk();
cnt = cmp::min(src.len(), dst.len() - off); cnt = cmp::min(src.len(), dst.len() - off);
ptr::copy_nonoverlapping(src.as_ptr(), dst[off..].as_mut_ptr(), cnt); ptr::copy_nonoverlapping(src.as_ptr(), dst[off..].as_mut_ptr(), cnt);
@@ -283,7 +283,7 @@ pub trait Buf {
/// This function panics if there is no more remaining data in `self`. /// This function panics if there is no more remaining data in `self`.
fn get_u8(&mut self) -> u8 { fn get_u8(&mut self) -> u8 {
assert!(self.remaining() >= 1); assert!(self.remaining() >= 1);
let ret = self.bytes()[0]; let ret = self.chunk()[0];
self.advance(1); self.advance(1);
ret ret
} }
@@ -306,7 +306,7 @@ pub trait Buf {
/// This function panics if there is no more remaining data in `self`. /// This function panics if there is no more remaining data in `self`.
fn get_i8(&mut self) -> i8 { fn get_i8(&mut self) -> i8 {
assert!(self.remaining() >= 1); assert!(self.remaining() >= 1);
let ret = self.bytes()[0] as i8; let ret = self.chunk()[0] as i8;
self.advance(1); self.advance(1);
ret ret
} }
@@ -861,7 +861,7 @@ pub trait Buf {
/// let mut chain = b"hello "[..].chain(&b"world"[..]); /// let mut chain = b"hello "[..].chain(&b"world"[..]);
/// ///
/// let full = chain.copy_to_bytes(11); /// let full = chain.copy_to_bytes(11);
/// assert_eq!(full.bytes(), b"hello world"); /// assert_eq!(full.chunk(), b"hello world");
/// ``` /// ```
fn chain<U: Buf>(self, next: U) -> Chain<Self, U> fn chain<U: Buf>(self, next: U) -> Chain<Self, U>
where where
@@ -908,13 +908,13 @@ macro_rules! deref_forward_buf {
(**self).remaining() (**self).remaining()
} }
fn bytes(&self) -> &[u8] { fn chunk(&self) -> &[u8] {
(**self).bytes() (**self).chunk()
} }
#[cfg(feature = "std")] #[cfg(feature = "std")]
fn bytes_vectored<'b>(&'b self, dst: &mut [IoSlice<'b>]) -> usize { fn chunks_vectored<'b>(&'b self, dst: &mut [IoSlice<'b>]) -> usize {
(**self).bytes_vectored(dst) (**self).chunks_vectored(dst)
} }
fn advance(&mut self, cnt: usize) { fn advance(&mut self, cnt: usize) {
@@ -1022,7 +1022,7 @@ impl Buf for &[u8] {
} }
#[inline] #[inline]
fn bytes(&self) -> &[u8] { fn chunk(&self) -> &[u8] {
self self
} }
@@ -1045,7 +1045,7 @@ impl<T: AsRef<[u8]>> Buf for std::io::Cursor<T> {
len - pos as usize len - pos as usize
} }
fn bytes(&self) -> &[u8] { fn chunk(&self) -> &[u8] {
let len = self.get_ref().as_ref().len(); let len = self.get_ref().as_ref().len();
let pos = self.position(); let pos = self.position();
src/buf/buf_mut.rs
+22 -22
View File
@@ -31,7 +31,7 @@ pub unsafe trait BufMut {
/// position until the end of the buffer is reached. /// position until the end of the buffer is reached.
/// ///
/// This value is greater than or equal to the length of the slice returned /// This value is greater than or equal to the length of the slice returned
/// by `bytes_mut`. /// by `chunk_mut()`.
/// ///
/// # Examples /// # Examples
/// ///
@@ -56,7 +56,7 @@ pub unsafe trait BufMut {
/// Advance the internal cursor of the BufMut /// Advance the internal cursor of the BufMut
/// ///
/// The next call to `bytes_mut` will return a slice starting `cnt` bytes /// The next call to `chunk_mut` will return a slice starting `cnt` bytes
/// further into the underlying buffer. /// further into the underlying buffer.
/// ///
/// This function is unsafe because there is no guarantee that the bytes /// This function is unsafe because there is no guarantee that the bytes
@@ -70,11 +70,11 @@ pub unsafe trait BufMut {
/// let mut buf = Vec::with_capacity(16); /// let mut buf = Vec::with_capacity(16);
/// ///
/// // Write some data /// // Write some data
/// buf.bytes_mut()[0..2].copy_from_slice(b"he"); /// buf.chunk_mut()[0..2].copy_from_slice(b"he");
/// unsafe { buf.advance_mut(2) }; /// unsafe { buf.advance_mut(2) };
/// ///
/// // write more bytes /// // write more bytes
/// buf.bytes_mut()[0..3].copy_from_slice(b"llo"); /// buf.chunk_mut()[0..3].copy_from_slice(b"llo");
/// ///
/// unsafe { buf.advance_mut(3); } /// unsafe { buf.advance_mut(3); }
/// ///
@@ -135,14 +135,14 @@ pub unsafe trait BufMut {
/// ///
/// unsafe { /// unsafe {
/// // MaybeUninit::as_mut_ptr /// // MaybeUninit::as_mut_ptr
/// buf.bytes_mut()[0..].as_mut_ptr().write(b'h'); /// buf.chunk_mut()[0..].as_mut_ptr().write(b'h');
/// buf.bytes_mut()[1..].as_mut_ptr().write(b'e'); /// buf.chunk_mut()[1..].as_mut_ptr().write(b'e');
/// ///
/// buf.advance_mut(2); /// buf.advance_mut(2);
/// ///
/// buf.bytes_mut()[0..].as_mut_ptr().write(b'l'); /// buf.chunk_mut()[0..].as_mut_ptr().write(b'l');
/// buf.bytes_mut()[1..].as_mut_ptr().write(b'l'); /// buf.chunk_mut()[1..].as_mut_ptr().write(b'l');
/// buf.bytes_mut()[2..].as_mut_ptr().write(b'o'); /// buf.chunk_mut()[2..].as_mut_ptr().write(b'o');
/// ///
/// buf.advance_mut(3); /// buf.advance_mut(3);
/// } /// }
@@ -153,12 +153,12 @@ pub unsafe trait BufMut {
/// ///
/// # Implementer notes /// # Implementer notes
/// ///
/// This function should never panic. `bytes_mut` should return an empty /// This function should never panic. `chunk_mut` should return an empty
/// slice **if and only if** `remaining_mut` returns 0. In other words, /// slice **if and only if** `remaining_mut()` returns 0. In other words,
/// `bytes_mut` returning an empty slice implies that `remaining_mut` will /// `chunk_mut()` returning an empty slice implies that `remaining_mut()` will
/// return 0 and `remaining_mut` returning 0 implies that `bytes_mut` will /// return 0 and `remaining_mut()` returning 0 implies that `chunk_mut()` will
/// return an empty slice. /// return an empty slice.
fn bytes_mut(&mut self) -> &mut UninitSlice; fn chunk_mut(&mut self) -> &mut UninitSlice;
/// Transfer bytes into `self` from `src` and advance the cursor by the /// Transfer bytes into `self` from `src` and advance the cursor by the
/// number of bytes written. /// number of bytes written.
@@ -190,8 +190,8 @@ pub unsafe trait BufMut {
let l; let l;
unsafe { unsafe {
let s = src.bytes(); let s = src.chunk();
let d = self.bytes_mut(); let d = self.chunk_mut();
l = cmp::min(s.len(), d.len()); l = cmp::min(s.len(), d.len());
ptr::copy_nonoverlapping(s.as_ptr(), d.as_mut_ptr() as *mut u8, l); ptr::copy_nonoverlapping(s.as_ptr(), d.as_mut_ptr() as *mut u8, l);
@@ -237,7 +237,7 @@ pub unsafe trait BufMut {
let cnt; let cnt;
unsafe { unsafe {
let dst = self.bytes_mut(); let dst = self.chunk_mut();
cnt = cmp::min(dst.len(), src.len() - off); cnt = cmp::min(dst.len(), src.len() - off);
ptr::copy_nonoverlapping(src[off..].as_ptr(), dst.as_mut_ptr() as *mut u8, cnt); ptr::copy_nonoverlapping(src[off..].as_ptr(), dst.as_mut_ptr() as *mut u8, cnt);
@@ -913,8 +913,8 @@ macro_rules! deref_forward_bufmut {
(**self).remaining_mut() (**self).remaining_mut()
} }
fn bytes_mut(&mut self) -> &mut UninitSlice { fn chunk_mut(&mut self) -> &mut UninitSlice {
(**self).bytes_mut() (**self).chunk_mut()
} }
unsafe fn advance_mut(&mut self, cnt: usize) { unsafe fn advance_mut(&mut self, cnt: usize) {
@@ -998,7 +998,7 @@ unsafe impl BufMut for &mut [u8] {
} }
#[inline] #[inline]
fn bytes_mut(&mut self) -> &mut UninitSlice { fn chunk_mut(&mut self) -> &mut UninitSlice {
// UninitSlice is repr(transparent), so safe to transmute // UninitSlice is repr(transparent), so safe to transmute
unsafe { &mut *(*self as *mut [u8] as *mut _) } unsafe { &mut *(*self as *mut [u8] as *mut _) }
} }
@@ -1033,7 +1033,7 @@ unsafe impl BufMut for Vec<u8> {
} }
#[inline] #[inline]
fn bytes_mut(&mut self) -> &mut UninitSlice { fn chunk_mut(&mut self) -> &mut UninitSlice {
if self.capacity() == self.len() { if self.capacity() == self.len() {
self.reserve(64); // Grow the vec self.reserve(64); // Grow the vec
} }
@@ -1060,7 +1060,7 @@ unsafe impl BufMut for Vec<u8> {
// a block to contain the src.bytes() borrow // a block to contain the src.bytes() borrow
{ {
let s = src.bytes(); let s = src.chunk();
l = s.len(); l = s.len();
self.extend_from_slice(s); self.extend_from_slice(s);
} }
src/buf/chain.rs
+9 -9
View File
@@ -138,11 +138,11 @@ where
self.a.remaining() + self.b.remaining() self.a.remaining() + self.b.remaining()
} }
fn bytes(&self) -> &[u8] { fn chunk(&self) -> &[u8] {
if self.a.has_remaining() { if self.a.has_remaining() {
self.a.bytes() self.a.chunk()
} else { } else {
self.b.bytes() self.b.chunk()
} }
} }
@@ -165,9 +165,9 @@ where
} }
#[cfg(feature = "std")] #[cfg(feature = "std")]
fn bytes_vectored<'a>(&'a self, dst: &mut [IoSlice<'a>]) -> usize { fn chunks_vectored<'a>(&'a self, dst: &mut [IoSlice<'a>]) -> usize {
let mut n = self.a.bytes_vectored(dst); let mut n = self.a.chunks_vectored(dst);
n += self.b.bytes_vectored(&mut dst[n..]); n += self.b.chunks_vectored(&mut dst[n..]);
n n
} }
} }
@@ -181,11 +181,11 @@ where
self.a.remaining_mut() + self.b.remaining_mut() self.a.remaining_mut() + self.b.remaining_mut()
} }
fn bytes_mut(&mut self) -> &mut UninitSlice { fn chunk_mut(&mut self) -> &mut UninitSlice {
if self.a.has_remaining_mut() { if self.a.has_remaining_mut() {
self.a.bytes_mut() self.a.chunk_mut()
} else { } else {
self.b.bytes_mut() self.b.chunk_mut()
} }
} }
src/buf/iter.rs
+1 -1
View File
@@ -117,7 +117,7 @@ impl<T: Buf> Iterator for IntoIter<T> {
return None; return None;
} }
let b = self.inner.bytes()[0]; let b = self.inner.chunk()[0];
self.inner.advance(1); self.inner.advance(1);
Some(b) Some(b)
src/buf/limit.rs
+2 -2
View File
@@ -61,8 +61,8 @@ unsafe impl<T: BufMut> BufMut for Limit<T> {
cmp::min(self.inner.remaining_mut(), self.limit) cmp::min(self.inner.remaining_mut(), self.limit)
} }
fn bytes_mut(&mut self) -> &mut UninitSlice { fn chunk_mut(&mut self) -> &mut UninitSlice {
let bytes = self.inner.bytes_mut(); let bytes = self.inner.chunk_mut();
let end = cmp::min(bytes.len(), self.limit); let end = cmp::min(bytes.len(), self.limit);
&mut bytes[..end] &mut bytes[..end]
} }
src/buf/reader.rs
+1 -1
View File
@@ -73,7 +73,7 @@ impl<B: Buf + Sized> io::Read for Reader<B> {
impl<B: Buf + Sized> io::BufRead for Reader<B> { impl<B: Buf + Sized> io::BufRead for Reader<B> {
fn fill_buf(&mut self) -> io::Result<&[u8]> { fn fill_buf(&mut self) -> io::Result<&[u8]> {
Ok(self.buf.bytes()) Ok(self.buf.chunk())
} }
fn consume(&mut self, amt: usize) { fn consume(&mut self, amt: usize) {
self.buf.advance(amt) self.buf.advance(amt)
src/buf/take.rs
+2 -2
View File
@@ -134,8 +134,8 @@ impl<T: Buf> Buf for Take<T> {
cmp::min(self.inner.remaining(), self.limit) cmp::min(self.inner.remaining(), self.limit)
} }
fn bytes(&self) -> &[u8] { fn chunk(&self) -> &[u8] {
let bytes = self.inner.bytes(); let bytes = self.inner.chunk();
&bytes[..cmp::min(bytes.len(), self.limit)] &bytes[..cmp::min(bytes.len(), self.limit)]
} }
src/buf/uninit_slice.rs
+3 -3
View File
@@ -6,7 +6,7 @@ use core::ops::{
/// Uninitialized byte slice. /// Uninitialized byte slice.
/// ///
/// Returned by `BufMut::bytes_mut()`, the referenced byte slice may be /// Returned by `BufMut::chunk_mut()`, the referenced byte slice may be
/// uninitialized. The wrapper provides safe access without introducing /// uninitialized. The wrapper provides safe access without introducing
/// undefined behavior. /// undefined behavior.
/// ///
@@ -114,7 +114,7 @@ impl UninitSlice {
/// ///
/// let mut data = [0, 1, 2]; /// let mut data = [0, 1, 2];
/// let mut slice = &mut data[..]; /// let mut slice = &mut data[..];
/// let ptr = BufMut::bytes_mut(&mut slice).as_mut_ptr(); /// let ptr = BufMut::chunk_mut(&mut slice).as_mut_ptr();
/// ``` /// ```
pub fn as_mut_ptr(&mut self) -> *mut u8 { pub fn as_mut_ptr(&mut self) -> *mut u8 {
self.0.as_mut_ptr() as *mut _ self.0.as_mut_ptr() as *mut _
@@ -129,7 +129,7 @@ impl UninitSlice {
/// ///
/// let mut data = [0, 1, 2]; /// let mut data = [0, 1, 2];
/// let mut slice = &mut data[..]; /// let mut slice = &mut data[..];
/// let len = BufMut::bytes_mut(&mut slice).len(); /// let len = BufMut::chunk_mut(&mut slice).len();
/// ///
/// assert_eq!(len, 3); /// assert_eq!(len, 3);
/// ``` /// ```
src/buf/vec_deque.rs
+1 -1
View File
@@ -7,7 +7,7 @@ impl Buf for VecDeque<u8> {
self.len() self.len()
} }
fn bytes(&self) -> &[u8] { fn chunk(&self) -> &[u8] {
let (s1, s2) = self.as_slices(); let (s1, s2) = self.as_slices();
if s1.is_empty() { if s1.is_empty() {
s2 s2
src/bytes.rs
+1 -1
View File
@@ -530,7 +530,7 @@ impl Buf for Bytes {
} }
#[inline] #[inline]
fn bytes(&self) -> &[u8] { fn chunk(&self) -> &[u8] {
self.as_slice() self.as_slice()
} }
src/bytes_mut.rs
+4 -4
View File
@@ -445,7 +445,7 @@ impl BytesMut {
let additional = new_len - len; let additional = new_len - len;
self.reserve(additional); self.reserve(additional);
unsafe { unsafe {
let dst = self.bytes_mut().as_mut_ptr(); let dst = self.chunk_mut().as_mut_ptr();
ptr::write_bytes(dst, value, additional); ptr::write_bytes(dst, value, additional);
self.set_len(new_len); self.set_len(new_len);
} }
@@ -944,7 +944,7 @@ impl Buf for BytesMut {
} }
#[inline] #[inline]
fn bytes(&self) -> &[u8] { fn chunk(&self) -> &[u8] {
self.as_slice() self.as_slice()
} }
@@ -985,7 +985,7 @@ unsafe impl BufMut for BytesMut {
} }
#[inline] #[inline]
fn bytes_mut(&mut self) -> &mut UninitSlice { fn chunk_mut(&mut self) -> &mut UninitSlice {
if self.capacity() == self.len() { if self.capacity() == self.len() {
self.reserve(64); self.reserve(64);
} }
@@ -1000,7 +1000,7 @@ unsafe impl BufMut for BytesMut {
Self: Sized, Self: Sized,
{ {
while src.has_remaining() { while src.has_remaining() {
let s = src.bytes(); let s = src.chunk();
let l = s.len(); let l = s.len();
self.extend_from_slice(s); self.extend_from_slice(s);
src.advance(l); src.advance(l);
tests/test_buf.rs
+8 -8
View File
@@ -9,17 +9,17 @@ fn test_fresh_cursor_vec() {
let mut buf = &b"hello"[..]; let mut buf = &b"hello"[..];
assert_eq!(buf.remaining(), 5); assert_eq!(buf.remaining(), 5);
assert_eq!(buf.bytes(), b"hello"); assert_eq!(buf.chunk(), b"hello");
buf.advance(2); buf.advance(2);
assert_eq!(buf.remaining(), 3); assert_eq!(buf.remaining(), 3);
assert_eq!(buf.bytes(), b"llo"); assert_eq!(buf.chunk(), b"llo");
buf.advance(3); buf.advance(3);
assert_eq!(buf.remaining(), 0); assert_eq!(buf.remaining(), 0);
assert_eq!(buf.bytes(), b""); assert_eq!(buf.chunk(), b"");
} }
#[test] #[test]
@@ -53,7 +53,7 @@ fn test_bufs_vec() {
let mut dst = [IoSlice::new(b1), IoSlice::new(b2)]; let mut dst = [IoSlice::new(b1), IoSlice::new(b2)];
assert_eq!(1, buf.bytes_vectored(&mut dst[..])); assert_eq!(1, buf.chunks_vectored(&mut dst[..]));
} }
#[test] #[test]
@@ -63,9 +63,9 @@ fn test_vec_deque() {
let mut buffer: VecDeque<u8> = VecDeque::new(); let mut buffer: VecDeque<u8> = VecDeque::new();
buffer.extend(b"hello world"); buffer.extend(b"hello world");
assert_eq!(11, buffer.remaining()); assert_eq!(11, buffer.remaining());
assert_eq!(b"hello world", buffer.bytes()); assert_eq!(b"hello world", buffer.chunk());
buffer.advance(6); buffer.advance(6);
assert_eq!(b"world", buffer.bytes()); assert_eq!(b"world", buffer.chunk());
buffer.extend(b" piece"); buffer.extend(b" piece");
let mut out = [0; 11]; let mut out = [0; 11];
buffer.copy_to_slice(&mut out); buffer.copy_to_slice(&mut out);
@@ -81,8 +81,8 @@ fn test_deref_buf_forwards() {
unreachable!("remaining"); unreachable!("remaining");
} }
fn bytes(&self) -> &[u8] { fn chunk(&self) -> &[u8] {
unreachable!("bytes"); unreachable!("chunk");
} }
fn advance(&mut self, _: usize) { fn advance(&mut self, _: usize) {
tests/test_buf_mut.rs
+3 -3
View File
@@ -11,7 +11,7 @@ fn test_vec_as_mut_buf() {
assert_eq!(buf.remaining_mut(), usize::MAX); assert_eq!(buf.remaining_mut(), usize::MAX);
assert!(buf.bytes_mut().len() >= 64); assert!(buf.chunk_mut().len() >= 64);
buf.put(&b"zomg"[..]); buf.put(&b"zomg"[..]);
@@ -81,8 +81,8 @@ fn test_deref_bufmut_forwards() {
unreachable!("remaining_mut"); unreachable!("remaining_mut");
} }
fn bytes_mut(&mut self) -> &mut UninitSlice { fn chunk_mut(&mut self) -> &mut UninitSlice {
unreachable!("bytes_mut"); unreachable!("chunk_mut");
} }
unsafe fn advance_mut(&mut self, _: usize) { unsafe fn advance_mut(&mut self, _: usize) {
tests/test_bytes.rs
+5 -5
View File
@@ -912,20 +912,20 @@ fn bytes_buf_mut_advance() {
let mut bytes = BytesMut::with_capacity(1024); let mut bytes = BytesMut::with_capacity(1024);
unsafe { unsafe {
let ptr = bytes.bytes_mut().as_mut_ptr(); let ptr = bytes.chunk_mut().as_mut_ptr();
assert_eq!(1024, bytes.bytes_mut().len()); assert_eq!(1024, bytes.chunk_mut().len());
bytes.advance_mut(10); bytes.advance_mut(10);
let next = bytes.bytes_mut().as_mut_ptr(); let next = bytes.chunk_mut().as_mut_ptr();
assert_eq!(1024 - 10, bytes.bytes_mut().len()); assert_eq!(1024 - 10, bytes.chunk_mut().len());
assert_eq!(ptr.offset(10), next); assert_eq!(ptr.offset(10), next);
// advance to the end // advance to the end
bytes.advance_mut(1024 - 10); bytes.advance_mut(1024 - 10);
// The buffer size is doubled // The buffer size is doubled
assert_eq!(1024, bytes.bytes_mut().len()); assert_eq!(1024, bytes.chunk_mut().len());
} }
} }
tests/test_chain.rs
+4 -4
View File
@@ -62,7 +62,7 @@ fn vectored_read() {
IoSlice::new(b4), IoSlice::new(b4),
]; ];
assert_eq!(2, buf.bytes_vectored(&mut iovecs)); assert_eq!(2, buf.chunks_vectored(&mut iovecs));
assert_eq!(iovecs[0][..], b"hello"[..]); assert_eq!(iovecs[0][..], b"hello"[..]);
assert_eq!(iovecs[1][..], b"world"[..]); assert_eq!(iovecs[1][..], b"world"[..]);
assert_eq!(iovecs[2][..], b""[..]); assert_eq!(iovecs[2][..], b""[..]);
@@ -83,7 +83,7 @@ fn vectored_read() {
IoSlice::new(b4), IoSlice::new(b4),
]; ];
assert_eq!(2, buf.bytes_vectored(&mut iovecs)); assert_eq!(2, buf.chunks_vectored(&mut iovecs));
assert_eq!(iovecs[0][..], b"llo"[..]); assert_eq!(iovecs[0][..], b"llo"[..]);
assert_eq!(iovecs[1][..], b"world"[..]); assert_eq!(iovecs[1][..], b"world"[..]);
assert_eq!(iovecs[2][..], b""[..]); assert_eq!(iovecs[2][..], b""[..]);
@@ -104,7 +104,7 @@ fn vectored_read() {
IoSlice::new(b4), IoSlice::new(b4),
]; ];
assert_eq!(1, buf.bytes_vectored(&mut iovecs)); assert_eq!(1, buf.chunks_vectored(&mut iovecs));
assert_eq!(iovecs[0][..], b"world"[..]); assert_eq!(iovecs[0][..], b"world"[..]);
assert_eq!(iovecs[1][..], b""[..]); assert_eq!(iovecs[1][..], b""[..]);
assert_eq!(iovecs[2][..], b""[..]); assert_eq!(iovecs[2][..], b""[..]);
@@ -125,7 +125,7 @@ fn vectored_read() {
IoSlice::new(b4), IoSlice::new(b4),
]; ];
assert_eq!(1, buf.bytes_vectored(&mut iovecs)); assert_eq!(1, buf.chunks_vectored(&mut iovecs));
assert_eq!(iovecs[0][..], b"ld"[..]); assert_eq!(iovecs[0][..], b"ld"[..]);
assert_eq!(iovecs[1][..], b""[..]); assert_eq!(iovecs[1][..], b""[..]);
assert_eq!(iovecs[2][..], b""[..]); assert_eq!(iovecs[2][..], b""[..]);
tests/test_take.rs
+1 -1
View File
@@ -8,5 +8,5 @@ fn long_take() {
// overrun the buffer. Regression test for #138. // overrun the buffer. Regression test for #138.
let buf = b"hello world".take(100); let buf = b"hello world".take(100);
assert_eq!(11, buf.remaining()); assert_eq!(11, buf.remaining());
assert_eq!(b"hello world", buf.bytes()); assert_eq!(b"hello world", buf.chunk());
} }