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

Remove buf::Source in favor of buf::IntoBuf

Browse Source 
The `Source` trait was essentially covering the same case as `IntoBuf`,
so remove it.

While technically a breaking change, this should not have any impact due
to:

1) There are no reverse dependencies that currently depend on `bytes`
2) Source was not supposed to be implemented externally
3) IntoBuf provides the same implementations as `Source`

Given these points, the change should be safe to apply.
This commit is contained in:
Carl Lerche
2017-03-07 11:30:08 -08:00
parent d70f575afd
commit 06b94c55b0
6 changed files with 123 additions and 154 deletions
Download Patch File Download Diff File Expand all files Collapse all files
src/buf/buf.rs
+28
View File
@@ -720,3 +720,31 @@ impl<T: AsRef<[u8]>> Buf for io::Cursor<T> {
self.set_position(pos as u64);
}
}
impl Buf for Option<[u8; 1]> {
fn remaining(&self) -> usize {
if self.is_some() {
1
} else {
0
}
}
fn bytes(&self) -> &[u8] {
self.as_ref().map(AsRef::as_ref)
.unwrap_or(Default::default())
}
fn advance(&mut self, cnt: usize) {
if cnt == 0 {
return;
}
if self.is_none() {
panic!("overflow");
} else {
assert_eq!(1, cnt);
*self = None;
}
}
}
src/buf/buf_mut.rs
+71 -3
View File
@@ -1,4 +1,4 @@
use super::{Source, Writer};
use super::{IntoBuf, Writer};
use byteorder::ByteOrder;
use iovec::IoVec;
@@ -219,8 +219,30 @@ pub trait BufMut {
/// # Panics
///
/// Panics if `self` does not have enough capacity to contain `src`.
fn put<S: Source>(&mut self, src: S) where Self: Sized {
src.copy_to_buf(self);
fn put<T: IntoBuf>(&mut self, src: T) where Self: Sized {
use super::Buf;
let mut src = src.into_buf();
assert!(self.remaining_mut() >= src.remaining());
while src.has_remaining() {
let l;
unsafe {
let s = src.bytes();
let d = self.bytes_mut();
l = cmp::min(s.len(), d.len());
ptr::copy_nonoverlapping(
s.as_ptr(),
d.as_mut_ptr(),
l);
}
src.advance(l);
unsafe { self.advance_mut(l); }
}
}
/// Transfer bytes into `self` from `src` and advance the cursor by the
@@ -268,6 +290,52 @@ pub trait BufMut {
}
}
/// Writes an unsigned 8 bit integer to `self`.
///
/// The current position is advanced by 1.
///
/// # Examples
///
/// ```
/// use bytes::BufMut;
///
/// let mut buf = vec![];
/// buf.put_u8(0x01);
/// assert_eq!(buf, b"\x01");
/// ```
///
/// # Panics
///
/// This function panics if there is not enough remaining capacity in
/// `self`.
fn put_u8(&mut self, n: u8) {
let src = [n];
self.put_slice(&src);
}
/// Writes a signed 8 bit integer to `self`.
///
/// The current position is advanced by 1.
///
/// # Examples
///
/// ```
/// use bytes::BufMut;
///
/// let mut buf = vec![];
/// buf.put_i8(0x01);
/// assert_eq!(buf, b"\x01");
/// ```
///
/// # Panics
///
/// This function panics if there is not enough remaining capacity in
/// `self`.
fn put_i8(&mut self, n: i8) {
let src = [n as u8];
self.put_slice(&src)
}
/// Writes an unsigned 16 bit integer to `self` in the specified byte order.
///
/// The current position is advanced by 2.
src/buf/into_buf.rs
+24 -8
View File
@@ -79,6 +79,14 @@ impl IntoBuf for Vec<u8> {
}
}
impl<'a> IntoBuf for &'a Vec<u8> {
type Buf = io::Cursor<&'a [u8]>;
fn into_buf(self) -> Self::Buf {
io::Cursor::new(&self[..])
}
}
// Kind of annoying... but this impl is required to allow passing `&'static
// [u8]` where for<'a> &'a T: IntoBuf is required.
impl<'a> IntoBuf for &'a &'static [u8] {
@@ -97,14 +105,6 @@ impl<'a> IntoBuf for &'a &'static str {
}
}
impl<'a> IntoBuf for &'a Vec<u8> {
type Buf = io::Cursor<&'a [u8]>;
fn into_buf(self) -> Self::Buf {
io::Cursor::new(&self[..])
}
}
impl IntoBuf for String {
type Buf = io::Cursor<Vec<u8>>;
@@ -120,3 +120,19 @@ impl<'a> IntoBuf for &'a String {
self.as_bytes().into_buf()
}
}
impl IntoBuf for u8 {
type Buf = Option<[u8; 1]>;
fn into_buf(self) -> Self::Buf {
Some([self])
}
}
impl IntoBuf for i8 {
type Buf = Option<[u8; 1]>;
fn into_buf(self) -> Self::Buf {
Some([self as u8; 1])
}
}
src/buf/mod.rs
-2
View File
@@ -23,7 +23,6 @@ mod chain;
mod into_buf;
mod iter;
mod reader;
mod source;
mod take;
mod writer;
@@ -34,6 +33,5 @@ pub use self::chain::Chain;
pub use self::into_buf::IntoBuf;
pub use self::iter::Iter;
pub use self::reader::Reader;
pub use self::source::Source;
pub use self::take::Take;
pub use self::writer::Writer;
src/buf/source.rs
-140
View File
@@ -1,140 +0,0 @@
use {Buf, BufMut, Bytes};
use std::{cmp, ptr};
/// A value that writes bytes from itself into a `BufMut`.
///
/// Values that implement `Source` are used as an argument to
/// [`BufMut::put`](trait.BufMut.html#method.put).
///
/// # Examples
///
/// ```
/// use bytes::{BufMut, Source};
///
/// struct Repeat {
/// num: usize,
/// str: String,
/// }
///
/// impl Source for Repeat {
/// fn copy_to_buf<B: BufMut>(self, buf: &mut B) {
/// for _ in 0..self.num {
/// buf.put(&self.str);
/// }
/// }
/// }
///
/// let mut dst = vec![];
/// dst.put(Repeat {
/// num: 3,
/// str: "hello".into(),
/// });
///
/// assert_eq!(*dst, b"hellohellohello"[..]);
/// ```
pub trait Source {
/// Copy data from self into destination buffer
///
/// # Examples
///
/// ```
/// use bytes::{BufMut, Source};
///
/// let mut dst = vec![];
///
/// "hello".copy_to_buf(&mut dst);
///
/// assert_eq!(*dst, b"hello"[..]);
/// ```
///
/// # Panics
///
/// This function panis if `buf` does not have enough capacity for `self`.
fn copy_to_buf<B: BufMut>(self, buf: &mut B);
}
impl Source for Vec<u8> {
fn copy_to_buf<B: BufMut>(self, buf: &mut B) {
buf.put_slice(&self[..]);
}
}
impl<'a> Source for &'a Vec<u8> {
fn copy_to_buf<B: BufMut>(self, buf: &mut B) {
buf.put_slice(&self[..]);
}
}
impl<'a> Source for &'a [u8] {
fn copy_to_buf<B: BufMut>(self, buf: &mut B) {
buf.put_slice(self);
}
}
impl Source for String {
fn copy_to_buf<B: BufMut>(self, buf: &mut B) {
buf.put_slice(self.as_bytes());
}
}
impl<'a> Source for &'a String {
fn copy_to_buf<B: BufMut>(self, buf: &mut B) {
buf.put_slice(self.as_bytes());
}
}
impl<'a> Source for &'a str {
fn copy_to_buf<B: BufMut>(self, buf: &mut B) {
buf.put_slice(self.as_bytes());
}
}
impl Source for u8 {
fn copy_to_buf<B: BufMut>(self, buf: &mut B) {
let src = [self];
buf.put_slice(&src);
}
}
impl Source for i8 {
fn copy_to_buf<B: BufMut>(self, buf: &mut B) {
buf.put_slice(&[self as u8])
}
}
impl Source for Bytes {
fn copy_to_buf<B: BufMut>(self, buf: &mut B) {
Source::copy_to_buf(self.as_ref(), buf);
}
}
impl<'a> Source for &'a Bytes {
fn copy_to_buf<B: BufMut>(self, buf: &mut B) {
Source::copy_to_buf(self.as_ref(), buf);
}
}
impl<T: Buf> Source for T {
fn copy_to_buf<B: BufMut>(mut self, buf: &mut B) {
assert!(buf.remaining_mut() >= self.remaining());
while self.has_remaining() {
let l;
unsafe {
let s = self.bytes();
let d = buf.bytes_mut();
l = cmp::min(s.len(), d.len());
ptr::copy_nonoverlapping(
s.as_ptr(),
d.as_mut_ptr(),
l);
}
self.advance(l);
unsafe { buf.advance_mut(l); }
}
}
}
src/lib.rs
-1
View File
@@ -83,7 +83,6 @@ pub use buf::{
#[deprecated(since = "0.4.1", note = "moved to `buf` module")]
#[doc(hidden)]
pub use buf::{
Source,
Reader,
Writer,
Take,