diff --git a/.travis.yml b/.travis.yml index 861903d24..74e096b9d 100644 --- a/.travis.yml +++ b/.travis.yml @@ -3,7 +3,8 @@ dist: trusty language: rust services: docker sudo: required -rust: stable +#rust: stable +rust: beta # we need 1.36, which is still beta env: global: @@ -19,7 +20,7 @@ matrix: # # This job will also build and deploy the docs to gh-pages. - env: TARGET=x86_64-unknown-linux-gnu - rust: 1.28.0 + #rust: 1.36.0 (not stable yet) after_success: - | pip install 'travis-cargo<0.2' --user && diff --git a/Cargo.toml b/Cargo.toml index 22e48c21d..b20130b0f 100644 --- a/Cargo.toml +++ b/Cargo.toml @@ -30,7 +30,6 @@ features = ["i128"] [dependencies] byteorder = "1.1.0" -iovec = { git = "https://github.com/carllerche/iovec" } serde = { version = "1.0", optional = true } either = { version = "1.5", default-features = false, optional = true } diff --git a/src/buf/buf.rs b/src/buf/buf.rs index a3e4d3f68..c064b517d 100644 --- a/src/buf/buf.rs +++ b/src/buf/buf.rs @@ -1,8 +1,7 @@ use super::{IntoBuf, Take, Reader, FromBuf, Chain}; use byteorder::{BigEndian, ByteOrder, LittleEndian}; -use iovec::IoVec; -use std::{cmp, ptr}; +use std::{cmp, io::IoSlice, ptr}; macro_rules! buf_get_impl { ($this:ident, $size:expr, $conv:path) => ({ @@ -119,14 +118,14 @@ pub trait Buf { /// Fills `dst` with potentially multiple slices starting at `self`'s /// current position. /// - /// If the `Buf` is backed by disjoint slices of bytes, `bytes_vec` enables - /// fetching more than one slice at once. `dst` is a slice of `IoVec` + /// If the `Buf` is backed by disjoint slices of bytes, `bytes_vectored` enables + /// fetching more than one slice at once. `dst` is a slice of `IoSlice` /// references, enabling the slice to be directly used with [`writev`] /// without any further conversion. The sum of the lengths of all the /// 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 slices **will not** be modified. If `bytes_vec` does not fill every + /// the slices **will not** be modified. If `bytes_vectored` does not fill every /// entry in `dst`, then `dst` is guaranteed to contain all remaining slices /// in `self. /// @@ -136,20 +135,20 @@ pub trait Buf { /// # Implementer notes /// /// This function should never panic. Once the end of the buffer is reached, - /// i.e., `Buf::remaining` returns 0, calls to `bytes_vec` must return 0 + /// i.e., `Buf::remaining` returns 0, calls to `bytes_vectored` must return 0 /// without mutating `dst`. /// /// Implementations should also take care to properly handle being called /// with `dst` being a zero length slice. /// /// [`writev`]: http://man7.org/linux/man-pages/man2/readv.2.html - fn bytes_vec<'a>(&'a self, dst: &mut [IoVec<'a>]) -> usize { + fn bytes_vectored<'a>(&'a self, dst: &mut [IoSlice<'a>]) -> usize { if dst.is_empty() { return 0; } if self.has_remaining() { - dst[0] = self.bytes().into(); + dst[0] = IoSlice::new(self.bytes()); 1 } else { 0 @@ -926,8 +925,8 @@ impl<'a, T: Buf + ?Sized> Buf for &'a mut T { (**self).bytes() } - fn bytes_vec<'b>(&'b self, dst: &mut [IoVec<'b>]) -> usize { - (**self).bytes_vec(dst) + fn bytes_vectored<'b>(&'b self, dst: &mut [IoSlice<'b>]) -> usize { + (**self).bytes_vectored(dst) } fn advance(&mut self, cnt: usize) { @@ -944,8 +943,8 @@ impl Buf for Box { (**self).bytes() } - fn bytes_vec<'b>(&'b self, dst: &mut [IoVec<'b>]) -> usize { - (**self).bytes_vec(dst) + fn bytes_vectored<'b>(&'b self, dst: &mut [IoSlice<'b>]) -> usize { + (**self).bytes_vectored(dst) } fn advance(&mut self, cnt: usize) { diff --git a/src/buf/buf_mut.rs b/src/buf/buf_mut.rs index c37fe1656..63aece806 100644 --- a/src/buf/buf_mut.rs +++ b/src/buf/buf_mut.rs @@ -1,8 +1,7 @@ use super::{IntoBuf, Writer}; use byteorder::{LittleEndian, ByteOrder, BigEndian}; -use iovec::IoVecMut; -use std::{cmp, ptr, usize}; +use std::{cmp, io::IoSliceMut, ptr, usize}; /// A trait for values that provide sequential write access to bytes. /// @@ -162,15 +161,15 @@ pub trait BufMut { /// Fills `dst` with potentially multiple mutable slices starting at `self`'s /// current position. /// - /// If the `BufMut` is backed by disjoint slices of bytes, `bytes_vec_mut` + /// If the `BufMut` is backed by disjoint slices of bytes, `bytes_vectored_mut` /// enables fetching more than one slice at once. `dst` is a slice of - /// mutable `IoVec` references, enabling the slice to be directly used with + /// mutable `IoSliceMut` references, enabling the slice to be directly used with /// [`readv`] without any further conversion. The sum of the lengths of all /// the buffers in `dst` will be less than or equal to /// `Buf::remaining_mut()`. /// /// The entries in `dst` will be overwritten, but the data **contained** by - /// the slices **will not** be modified. If `bytes_vec_mut` does not fill every + /// the slices **will not** be modified. If `bytes_vectored_mut` does not fill every /// entry in `dst`, then `dst` is guaranteed to contain all remaining slices /// in `self. /// @@ -180,20 +179,20 @@ pub trait BufMut { /// # Implementer notes /// /// This function should never panic. Once the end of the buffer is reached, - /// i.e., `BufMut::remaining_mut` returns 0, calls to `bytes_vec_mut` must + /// i.e., `BufMut::remaining_mut` returns 0, calls to `bytes_vectored_mut` must /// return 0 without mutating `dst`. /// /// Implementations should also take care to properly handle being called /// with `dst` being a zero length slice. /// /// [`readv`]: http://man7.org/linux/man-pages/man2/readv.2.html - unsafe fn bytes_vec_mut<'a>(&'a mut self, dst: &mut [IoVecMut<'a>]) -> usize { + unsafe fn bytes_vectored_mut<'a>(&'a mut self, dst: &mut [IoSliceMut<'a>]) -> usize { if dst.is_empty() { return 0; } if self.has_remaining_mut() { - dst[0] = self.bytes_mut().into(); + dst[0] = IoSliceMut::new(self.bytes_mut()); 1 } else { 0 @@ -989,8 +988,8 @@ impl<'a, T: BufMut + ?Sized> BufMut for &'a mut T { (**self).bytes_mut() } - unsafe fn bytes_vec_mut<'b>(&'b mut self, dst: &mut [IoVecMut<'b>]) -> usize { - (**self).bytes_vec_mut(dst) + unsafe fn bytes_vectored_mut<'b>(&'b mut self, dst: &mut [IoSliceMut<'b>]) -> usize { + (**self).bytes_vectored_mut(dst) } unsafe fn advance_mut(&mut self, cnt: usize) { @@ -1007,8 +1006,8 @@ impl BufMut for Box { (**self).bytes_mut() } - unsafe fn bytes_vec_mut<'b>(&'b mut self, dst: &mut [IoVecMut<'b>]) -> usize { - (**self).bytes_vec_mut(dst) + unsafe fn bytes_vectored_mut<'b>(&'b mut self, dst: &mut [IoSliceMut<'b>]) -> usize { + (**self).bytes_vectored_mut(dst) } unsafe fn advance_mut(&mut self, cnt: usize) { diff --git a/src/buf/chain.rs b/src/buf/chain.rs index d33e62b33..4d46a5d0a 100644 --- a/src/buf/chain.rs +++ b/src/buf/chain.rs @@ -1,6 +1,6 @@ use {Buf, BufMut}; use buf::IntoIter; -use iovec::{IoVec, IoVecMut}; +use std::io::{IoSlice, IoSliceMut}; /// A `Chain` sequences two buffers. /// @@ -178,9 +178,9 @@ impl Buf for Chain self.b.advance(cnt); } - fn bytes_vec<'a>(&'a self, dst: &mut [IoVec<'a>]) -> usize { - let mut n = self.a.bytes_vec(dst); - n += self.b.bytes_vec(&mut dst[n..]); + fn bytes_vectored<'a>(&'a self, dst: &mut [IoSlice<'a>]) -> usize { + let mut n = self.a.bytes_vectored(dst); + n += self.b.bytes_vectored(&mut dst[n..]); n } } @@ -219,9 +219,9 @@ impl BufMut for Chain self.b.advance_mut(cnt); } - unsafe fn bytes_vec_mut<'a>(&'a mut self, dst: &mut [IoVecMut<'a>]) -> usize { - let mut n = self.a.bytes_vec_mut(dst); - n += self.b.bytes_vec_mut(&mut dst[n..]); + unsafe fn bytes_vectored_mut<'a>(&'a mut self, dst: &mut [IoSliceMut<'a>]) -> usize { + let mut n = self.a.bytes_vectored_mut(dst); + n += self.b.bytes_vectored_mut(&mut dst[n..]); n } } diff --git a/src/either.rs b/src/either.rs index b3c780168..dba5d52cd 100644 --- a/src/either.rs +++ b/src/either.rs @@ -4,7 +4,7 @@ use {Buf, BufMut}; use self::either::Either; use self::either::Either::*; -use iovec::{IoVec, IoVecMut}; +use std::io::{IoSlice, IoSliceMut}; impl Buf for Either where @@ -25,10 +25,10 @@ where } } - fn bytes_vec<'a>(&'a self, dst: &mut [IoVec<'a>]) -> usize { + fn bytes_vectored<'a>(&'a self, dst: &mut [IoSlice<'a>]) -> usize { match *self { - Left(ref b) => b.bytes_vec(dst), - Right(ref b) => b.bytes_vec(dst), + Left(ref b) => b.bytes_vectored(dst), + Right(ref b) => b.bytes_vectored(dst), } } @@ -66,10 +66,10 @@ where } } - unsafe fn bytes_vec_mut<'a>(&'a mut self, dst: &mut [IoVecMut<'a>]) -> usize { + unsafe fn bytes_vectored_mut<'a>(&'a mut self, dst: &mut [IoSliceMut<'a>]) -> usize { match *self { - Left(ref mut b) => b.bytes_vec_mut(dst), - Right(ref mut b) => b.bytes_vec_mut(dst), + Left(ref mut b) => b.bytes_vectored_mut(dst), + Right(ref mut b) => b.bytes_vectored_mut(dst), } } diff --git a/src/lib.rs b/src/lib.rs index ec0ed7a4c..d9a347cf1 100644 --- a/src/lib.rs +++ b/src/lib.rs @@ -72,7 +72,6 @@ #![doc(html_root_url = "https://docs.rs/bytes/0.5.0")] extern crate byteorder; -extern crate iovec; pub mod buf; pub use buf::{ diff --git a/tests/test_buf.rs b/tests/test_buf.rs index fcc5999a0..da0efe72b 100644 --- a/tests/test_buf.rs +++ b/tests/test_buf.rs @@ -1,9 +1,8 @@ extern crate bytes; extern crate byteorder; -extern crate iovec; use bytes::Buf; -use iovec::IoVec; +use std::io::IoSlice; #[test] fn test_fresh_cursor_vec() { @@ -48,11 +47,10 @@ fn test_get_u16_buffer_underflow() { fn test_bufs_vec() { let buf = &b"hello world"[..]; - let b1: &[u8] = &mut [0]; - let b2: &[u8] = &mut [0]; + let b1: &[u8] = &mut []; + let b2: &[u8] = &mut []; - let mut dst: [IoVec; 2] = - [b1.into(), b2.into()]; + let mut dst = [IoSlice::new(b1), IoSlice::new(b2)]; - assert_eq!(1, buf.bytes_vec(&mut dst[..])); + assert_eq!(1, buf.bytes_vectored(&mut dst[..])); } diff --git a/tests/test_buf_mut.rs b/tests/test_buf_mut.rs index cdac796f1..acc6af6f4 100644 --- a/tests/test_buf_mut.rs +++ b/tests/test_buf_mut.rs @@ -1,11 +1,10 @@ extern crate bytes; extern crate byteorder; -extern crate iovec; use bytes::{BufMut, BytesMut}; -use iovec::IoVecMut; use std::usize; use std::fmt::Write; +use std::io::IoSliceMut; #[test] fn test_vec_as_mut_buf() { @@ -72,13 +71,13 @@ fn test_clone() { #[test] fn test_bufs_vec_mut() { - use std::mem; - let mut buf = BytesMut::from(&b"hello world"[..]); + let b1: &mut [u8] = &mut []; + let b2: &mut [u8] = &mut []; + let mut dst = [IoSliceMut::new(b1), IoSliceMut::new(b2)]; unsafe { - let mut dst: [IoVecMut; 2] = mem::zeroed(); - assert_eq!(1, buf.bytes_vec_mut(&mut dst[..])); + assert_eq!(1, buf.bytes_vectored_mut(&mut dst[..])); } } diff --git a/tests/test_chain.rs b/tests/test_chain.rs index b26722560..582c65716 100644 --- a/tests/test_chain.rs +++ b/tests/test_chain.rs @@ -1,9 +1,8 @@ extern crate bytes; -extern crate iovec; use bytes::{Buf, BufMut, Bytes, BytesMut}; use bytes::buf::Chain; -use iovec::IoVec; +use std::io::IoSlice; #[test] fn collect_two_bufs() { @@ -54,68 +53,84 @@ fn vectored_read() { let mut buf = a.chain(b); { - let b1: &[u8] = &mut [0]; - let b2: &[u8] = &mut [0]; - let b3: &[u8] = &mut [0]; - let b4: &[u8] = &mut [0]; - let mut iovecs: [IoVec; 4] = - [b1.into(), b2.into(), b3.into(), b4.into()]; - - assert_eq!(2, buf.bytes_vec(&mut iovecs)); + let b1: &[u8] = &mut []; + let b2: &[u8] = &mut []; + let b3: &[u8] = &mut []; + let b4: &[u8] = &mut []; + let mut iovecs = [ + IoSlice::new(b1), + IoSlice::new(b2), + IoSlice::new(b3), + IoSlice::new(b4), + ]; + + assert_eq!(2, buf.bytes_vectored(&mut iovecs)); assert_eq!(iovecs[0][..], b"hello"[..]); assert_eq!(iovecs[1][..], b"world"[..]); - assert_eq!(iovecs[2][..], b"\0"[..]); - assert_eq!(iovecs[3][..], b"\0"[..]); + assert_eq!(iovecs[2][..], b""[..]); + assert_eq!(iovecs[3][..], b""[..]); } buf.advance(2); { - let b1: &[u8] = &mut [0]; - let b2: &[u8] = &mut [0]; - let b3: &[u8] = &mut [0]; - let b4: &[u8] = &mut [0]; - let mut iovecs: [IoVec; 4] = - [b1.into(), b2.into(), b3.into(), b4.into()]; - - assert_eq!(2, buf.bytes_vec(&mut iovecs)); + let b1: &[u8] = &mut []; + let b2: &[u8] = &mut []; + let b3: &[u8] = &mut []; + let b4: &[u8] = &mut []; + let mut iovecs = [ + IoSlice::new(b1), + IoSlice::new(b2), + IoSlice::new(b3), + IoSlice::new(b4), + ]; + + assert_eq!(2, buf.bytes_vectored(&mut iovecs)); assert_eq!(iovecs[0][..], b"llo"[..]); assert_eq!(iovecs[1][..], b"world"[..]); - assert_eq!(iovecs[2][..], b"\0"[..]); - assert_eq!(iovecs[3][..], b"\0"[..]); + assert_eq!(iovecs[2][..], b""[..]); + assert_eq!(iovecs[3][..], b""[..]); } buf.advance(3); { - let b1: &[u8] = &mut [0]; - let b2: &[u8] = &mut [0]; - let b3: &[u8] = &mut [0]; - let b4: &[u8] = &mut [0]; - let mut iovecs: [IoVec; 4] = - [b1.into(), b2.into(), b3.into(), b4.into()]; - - assert_eq!(1, buf.bytes_vec(&mut iovecs)); + let b1: &[u8] = &mut []; + let b2: &[u8] = &mut []; + let b3: &[u8] = &mut []; + let b4: &[u8] = &mut []; + let mut iovecs = [ + IoSlice::new(b1), + IoSlice::new(b2), + IoSlice::new(b3), + IoSlice::new(b4), + ]; + + assert_eq!(1, buf.bytes_vectored(&mut iovecs)); assert_eq!(iovecs[0][..], b"world"[..]); - assert_eq!(iovecs[1][..], b"\0"[..]); - assert_eq!(iovecs[2][..], b"\0"[..]); - assert_eq!(iovecs[3][..], b"\0"[..]); + assert_eq!(iovecs[1][..], b""[..]); + assert_eq!(iovecs[2][..], b""[..]); + assert_eq!(iovecs[3][..], b""[..]); } buf.advance(3); { - let b1: &[u8] = &mut [0]; - let b2: &[u8] = &mut [0]; - let b3: &[u8] = &mut [0]; - let b4: &[u8] = &mut [0]; - let mut iovecs: [IoVec; 4] = - [b1.into(), b2.into(), b3.into(), b4.into()]; - - assert_eq!(1, buf.bytes_vec(&mut iovecs)); + let b1: &[u8] = &mut []; + let b2: &[u8] = &mut []; + let b3: &[u8] = &mut []; + let b4: &[u8] = &mut []; + let mut iovecs = [ + IoSlice::new(b1), + IoSlice::new(b2), + IoSlice::new(b3), + IoSlice::new(b4), + ]; + + assert_eq!(1, buf.bytes_vectored(&mut iovecs)); assert_eq!(iovecs[0][..], b"ld"[..]); - assert_eq!(iovecs[1][..], b"\0"[..]); - assert_eq!(iovecs[2][..], b"\0"[..]); - assert_eq!(iovecs[3][..], b"\0"[..]); + assert_eq!(iovecs[1][..], b""[..]); + assert_eq!(iovecs[2][..], b""[..]); + assert_eq!(iovecs[3][..], b""[..]); } }