mirror of
https://github.com/tokio-rs/bytes.git
synced 2026-08-16 00:00:15 +02:00
Restructure and trim down the library
This commit is a significant overhaul of the library in an effort to head towards a stable API. The rope implementation as well as a number of buffer implementations have been removed from the library and will live at https://github.com/carllerche/bytes-more while they incubate. **Bytes / BytesMut** `Bytes` is now an atomic ref counted byte slice. As it is contigous, it offers a richer API than before. `BytesMut` is a mutable variant. It is safe by ensuring that it is the only handle to a given byte slice. **AppendBuf -> ByteBuf** `AppendBuf` has been replaced by `ByteBuf`. The API is not identical, but is close enough to be considered a suitable replacement. **Removed types** The following types have been removed in favor of living in bytes-more * RingBuf * BlockBuf * `Bytes` as a rope implementation * ReadExt * WriteExt
This commit is contained in:
Carl Lerche
+204
@@ -0,0 +1,204 @@
|
||||
use {Buf, BufMut, BytesMut};
|
||||
|
||||
use std::{cmp, fmt};
|
||||
|
||||
/// A buffer backed by `BytesMut`
|
||||
pub struct ByteBuf {
|
||||
mem: BytesMut,
|
||||
rd: usize,
|
||||
}
|
||||
|
||||
impl ByteBuf {
|
||||
/// Create a new `ByteBuf` with 8kb capacity
|
||||
pub fn new() -> ByteBuf {
|
||||
ByteBuf::with_capacity(8 * 1024)
|
||||
}
|
||||
|
||||
/// Create a new `ByteBuf` with `cap` capacity
|
||||
pub fn with_capacity(cap: usize) -> ByteBuf {
|
||||
ByteBuf {
|
||||
mem: BytesMut::with_capacity(cap),
|
||||
rd: 0,
|
||||
}
|
||||
}
|
||||
|
||||
/// Create a new `ByteBuf` backed by `bytes`
|
||||
pub fn from_bytes(bytes: BytesMut) -> ByteBuf {
|
||||
ByteBuf {
|
||||
mem: bytes,
|
||||
rd: 0,
|
||||
}
|
||||
}
|
||||
|
||||
/// Create a new `ByteBuf` containing the given slice
|
||||
pub fn from_slice<T: AsRef<[u8]>>(bytes: T) -> ByteBuf {
|
||||
let mut buf = ByteBuf::with_capacity(bytes.as_ref().len());
|
||||
buf.copy_from_slice(bytes.as_ref());
|
||||
buf
|
||||
}
|
||||
|
||||
/// Return the number of bytes the buffer can contain
|
||||
pub fn capacity(&self) -> usize {
|
||||
self.mem.capacity()
|
||||
}
|
||||
|
||||
/// Return the read cursor position
|
||||
pub fn position(&self) -> usize {
|
||||
self.rd
|
||||
}
|
||||
|
||||
/// Set the read cursor position
|
||||
pub fn set_position(&mut self, position: usize) {
|
||||
assert!(position <= self.mem.len(), "position out of bounds");
|
||||
self.rd = position
|
||||
}
|
||||
|
||||
/// Return the number of buffered bytes
|
||||
pub fn len(&self) -> usize {
|
||||
self.mem.len()
|
||||
}
|
||||
|
||||
/// Returns `true` if the buffer contains no unread bytes
|
||||
pub fn is_empty(&self) -> bool {
|
||||
self.mem.is_empty()
|
||||
}
|
||||
|
||||
/// Clears the buffer, removing any written data
|
||||
pub fn clear(&mut self) {
|
||||
self.rd = 0;
|
||||
unsafe { self.mem.set_len(0); }
|
||||
}
|
||||
|
||||
/// Splits the buffer into two at the current read index.
|
||||
pub fn drain_read(&mut self) -> BytesMut {
|
||||
let drained = self.mem.drain_to(self.rd);
|
||||
self.rd = 0;
|
||||
drained
|
||||
}
|
||||
|
||||
/// Splits the buffer into two at the given index.
|
||||
pub fn drain_to(&mut self, at: usize) -> BytesMut {
|
||||
let drained = self.mem.drain_to(at);
|
||||
|
||||
if at >= self.rd {
|
||||
self.rd = 0;
|
||||
} else {
|
||||
self.rd -= at;
|
||||
}
|
||||
|
||||
drained
|
||||
}
|
||||
|
||||
/// Reserves capacity for at least additional more bytes to be written in
|
||||
/// the given `ByteBuf`. The `ByteBuf` may reserve more space to avoid
|
||||
/// frequent reallocations.
|
||||
pub fn reserve(&mut self, additional: usize) {
|
||||
if self.remaining_mut() < additional {
|
||||
let cap = cmp::max(self.capacity() * 2, self.len() + additional);
|
||||
let cap = cap.next_power_of_two();
|
||||
|
||||
let mut new = ByteBuf::with_capacity(cap);
|
||||
|
||||
new.copy_from_slice(self.mem.as_ref());
|
||||
new.rd = self.rd;
|
||||
|
||||
*self = new;
|
||||
}
|
||||
}
|
||||
|
||||
/// Reserves the minimum capacity for exactly additional more bytes to be
|
||||
/// written in the given `ByteBuf`. Does nothing if the capacity is already
|
||||
/// sufficient.
|
||||
///
|
||||
/// Note that the allocator may give the collection more space than it
|
||||
/// requests. Therefore capacity can not be relied upon to be precisely
|
||||
/// minimal. Prefer reserve if future insertions are expected.
|
||||
pub fn reserve_exact(&mut self, additional: usize) {
|
||||
if self.remaining_mut() < additional {
|
||||
let cap = self.len() + additional;
|
||||
let mut new = ByteBuf::with_capacity(cap);
|
||||
|
||||
new.copy_from_slice(self.mem.as_ref());
|
||||
new.rd = self.rd;
|
||||
|
||||
*self = new;
|
||||
}
|
||||
}
|
||||
|
||||
/// Gets a reference to the underlying `BytesMut`
|
||||
pub fn get_ref(&self) -> &BytesMut {
|
||||
&self.mem
|
||||
}
|
||||
|
||||
/// Unwraps the `ByteBuf`, returning the underlying `BytesMut`
|
||||
pub fn into_inner(self) -> BytesMut {
|
||||
self.mem
|
||||
}
|
||||
}
|
||||
|
||||
impl Buf for ByteBuf {
|
||||
fn remaining(&self) -> usize {
|
||||
self.len() - self.rd
|
||||
}
|
||||
|
||||
fn bytes(&self) -> &[u8] {
|
||||
&self.mem[self.rd..]
|
||||
}
|
||||
|
||||
fn advance(&mut self, cnt: usize) {
|
||||
assert!(cnt <= self.remaining(), "buffer overflow");
|
||||
self.rd += cnt;
|
||||
}
|
||||
|
||||
fn copy_to_slice(&mut self, dst: &mut [u8]) {
|
||||
assert!(self.remaining() >= dst.len());
|
||||
|
||||
let len = dst.len();
|
||||
dst.copy_from_slice(&self.bytes()[..len]);
|
||||
self.rd += len;
|
||||
}
|
||||
}
|
||||
|
||||
impl BufMut for ByteBuf {
|
||||
fn remaining_mut(&self) -> usize {
|
||||
self.capacity() - self.len()
|
||||
}
|
||||
|
||||
unsafe fn advance_mut(&mut self, cnt: usize) {
|
||||
let new_len = self.len() + cnt;
|
||||
self.mem.set_len(new_len);
|
||||
}
|
||||
|
||||
unsafe fn bytes_mut(&mut self) -> &mut [u8] {
|
||||
let len = self.len();
|
||||
&mut self.mem.as_raw()[len..]
|
||||
}
|
||||
|
||||
fn copy_from_slice(&mut self, src: &[u8]) {
|
||||
assert!(self.remaining_mut() >= src.len());
|
||||
|
||||
let len = src.len();
|
||||
|
||||
unsafe {
|
||||
self.bytes_mut()[..len].copy_from_slice(src);
|
||||
self.advance_mut(len);
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
impl fmt::Debug for ByteBuf {
|
||||
fn fmt(&self, fmt: &mut fmt::Formatter) -> fmt::Result {
|
||||
self.bytes().fmt(fmt)
|
||||
}
|
||||
}
|
||||
|
||||
impl fmt::Write for ByteBuf {
|
||||
fn write_str(&mut self, s: &str) -> fmt::Result {
|
||||
BufMut::put_str(self, s);
|
||||
Ok(())
|
||||
}
|
||||
|
||||
fn write_fmt(&mut self, args: fmt::Arguments) -> fmt::Result {
|
||||
fmt::write(self, args)
|
||||
}
|
||||
}
|
||||
+721
@@ -0,0 +1,721 @@
|
||||
pub mod byte;
|
||||
pub mod slice;
|
||||
pub mod take;
|
||||
|
||||
use {Bytes, Take, TakeMut};
|
||||
use byteorder::ByteOrder;
|
||||
use std::{cmp, io, ptr, usize};
|
||||
|
||||
/// A trait for values that provide sequential read access to bytes.
|
||||
pub trait Buf {
|
||||
|
||||
/// Returns the number of bytes that can be accessed from the Buf
|
||||
fn remaining(&self) -> usize;
|
||||
|
||||
/// Returns a slice starting at the current Buf position and of length
|
||||
/// between 0 and `Buf::remaining()`.
|
||||
fn bytes(&self) -> &[u8];
|
||||
|
||||
/// Advance the internal cursor of the Buf
|
||||
fn advance(&mut self, cnt: usize);
|
||||
|
||||
/// Returns true if there are any more bytes to consume
|
||||
fn has_remaining(&self) -> bool {
|
||||
self.remaining() > 0
|
||||
}
|
||||
|
||||
/// Copies bytes from `self` into `dst`
|
||||
///
|
||||
/// # Panics
|
||||
///
|
||||
/// The function panics if `self` does not contain enough bytes to fill
|
||||
/// `dst`.
|
||||
fn copy_to<S: Sink + ?Sized>(&mut self, dst: &mut S) where Self: Sized {
|
||||
dst.sink(self);
|
||||
}
|
||||
|
||||
/// Copies bytes from the `Buf` into the given slice and advance the cursor by
|
||||
/// the number of bytes copied.
|
||||
///
|
||||
/// ```
|
||||
/// use std::io::Cursor;
|
||||
/// use bytes::Buf;
|
||||
///
|
||||
/// let mut buf = Cursor::new(b"hello world");
|
||||
/// let mut dst = [0; 5];
|
||||
///
|
||||
/// buf.copy_to_slice(&mut dst);
|
||||
/// assert_eq!(b"hello", &dst);
|
||||
/// assert_eq!(6, buf.remaining());
|
||||
/// ```
|
||||
///
|
||||
/// # Panics
|
||||
///
|
||||
/// This function panics if `self.remaining() < dst.len()`
|
||||
fn copy_to_slice(&mut self, dst: &mut [u8]) {
|
||||
let mut off = 0;
|
||||
|
||||
assert!(self.remaining() >= dst.len());
|
||||
|
||||
while off < dst.len() {
|
||||
let cnt;
|
||||
|
||||
unsafe {
|
||||
let src = self.bytes();
|
||||
cnt = cmp::min(src.len(), dst.len() - off);
|
||||
|
||||
ptr::copy_nonoverlapping(
|
||||
src.as_ptr(), dst[off..].as_mut_ptr(), cnt);
|
||||
|
||||
off += src.len();
|
||||
}
|
||||
|
||||
self.advance(cnt);
|
||||
}
|
||||
}
|
||||
|
||||
/// Gets an unsigned 8 bit integer from the `Buf` without advancing the
|
||||
/// buffer cursor
|
||||
fn peek_u8(&self) -> Option<u8> {
|
||||
if self.has_remaining() {
|
||||
Some(self.bytes()[0])
|
||||
} else {
|
||||
None
|
||||
}
|
||||
}
|
||||
|
||||
/// Gets an unsigned 8 bit integer from the `Buf`.
|
||||
fn get_u8(&mut self) -> u8 {
|
||||
let mut buf = [0; 1];
|
||||
self.copy_to_slice(&mut buf);
|
||||
buf[0]
|
||||
}
|
||||
|
||||
/// Gets a signed 8 bit integer from the `Buf`.
|
||||
fn get_i8(&mut self) -> i8 {
|
||||
let mut buf = [0; 1];
|
||||
self.copy_to_slice(&mut buf);
|
||||
buf[0] as i8
|
||||
}
|
||||
|
||||
/// Gets an unsigned 16 bit integer from the `Buf`
|
||||
fn get_u16<T: ByteOrder>(&mut self) -> u16 {
|
||||
let mut buf = [0; 2];
|
||||
self.copy_to_slice(&mut buf);
|
||||
T::read_u16(&buf)
|
||||
}
|
||||
|
||||
/// Gets a signed 16 bit integer from the `Buf`
|
||||
fn get_i16<T: ByteOrder>(&mut self) -> i16 {
|
||||
let mut buf = [0; 2];
|
||||
self.copy_to_slice(&mut buf);
|
||||
T::read_i16(&buf)
|
||||
}
|
||||
|
||||
/// Gets an unsigned 32 bit integer from the `Buf`
|
||||
fn get_u32<T: ByteOrder>(&mut self) -> u32 {
|
||||
let mut buf = [0; 4];
|
||||
self.copy_to_slice(&mut buf);
|
||||
T::read_u32(&buf)
|
||||
}
|
||||
|
||||
/// Gets a signed 32 bit integer from the `Buf`
|
||||
fn get_i32<T: ByteOrder>(&mut self) -> i32 {
|
||||
let mut buf = [0; 4];
|
||||
self.copy_to_slice(&mut buf);
|
||||
T::read_i32(&buf)
|
||||
}
|
||||
|
||||
/// Gets an unsigned 64 bit integer from the `Buf`
|
||||
fn get_u64<T: ByteOrder>(&mut self) -> u64 {
|
||||
let mut buf = [0; 8];
|
||||
self.copy_to_slice(&mut buf);
|
||||
T::read_u64(&buf)
|
||||
}
|
||||
|
||||
/// Gets a signed 64 bit integer from the `Buf`
|
||||
fn get_i64<T: ByteOrder>(&mut self) -> i64 {
|
||||
let mut buf = [0; 8];
|
||||
self.copy_to_slice(&mut buf);
|
||||
T::read_i64(&buf)
|
||||
}
|
||||
|
||||
/// Gets an unsigned n-bytes integer from the `Buf`
|
||||
fn get_uint<T: ByteOrder>(&mut self, nbytes: usize) -> u64 {
|
||||
let mut buf = [0; 8];
|
||||
self.copy_to_slice(&mut buf[..nbytes]);
|
||||
T::read_uint(&buf[..nbytes], nbytes)
|
||||
}
|
||||
|
||||
/// Gets a signed n-bytes integer from the `Buf`
|
||||
fn get_int<T: ByteOrder>(&mut self, nbytes: usize) -> i64 {
|
||||
let mut buf = [0; 8];
|
||||
self.copy_to_slice(&mut buf[..nbytes]);
|
||||
T::read_int(&buf[..nbytes], nbytes)
|
||||
}
|
||||
|
||||
/// Gets a IEEE754 single-precision (4 bytes) floating point number from
|
||||
/// the `Buf`
|
||||
fn get_f32<T: ByteOrder>(&mut self) -> f32 {
|
||||
let mut buf = [0; 4];
|
||||
self.copy_to_slice(&mut buf);
|
||||
T::read_f32(&buf)
|
||||
}
|
||||
|
||||
/// Gets a IEEE754 double-precision (8 bytes) floating point number from
|
||||
/// the `Buf`
|
||||
fn get_f64<T: ByteOrder>(&mut self) -> f64 {
|
||||
let mut buf = [0; 8];
|
||||
self.copy_to_slice(&mut buf);
|
||||
T::read_f64(&buf)
|
||||
}
|
||||
|
||||
/// Creates a "by reference" adaptor for this instance of Buf
|
||||
fn by_ref(&mut self) -> &mut Self where Self: Sized {
|
||||
self
|
||||
}
|
||||
|
||||
/// Create an adapter which will limit at most `limit` bytes from it.
|
||||
fn take(self, limit: usize) -> Take<Self> where Self: Sized {
|
||||
take::new(self, limit)
|
||||
}
|
||||
|
||||
/// Return a `Reader` for the value. Allows using a `Buf` as an `io::Read`
|
||||
fn reader(self) -> Reader<Self> where Self: Sized {
|
||||
Reader::new(self)
|
||||
}
|
||||
}
|
||||
|
||||
/// A trait for values that provide sequential write access to bytes.
|
||||
pub trait BufMut {
|
||||
|
||||
/// Returns the number of bytes that can be written to the BufMut
|
||||
fn remaining_mut(&self) -> usize;
|
||||
|
||||
/// Advance the internal cursor of the BufMut
|
||||
unsafe fn advance_mut(&mut self, cnt: usize);
|
||||
|
||||
/// Returns true iff there is any more space for bytes to be written
|
||||
fn has_remaining_mut(&self) -> bool {
|
||||
self.remaining_mut() > 0
|
||||
}
|
||||
|
||||
/// Returns a mutable slice starting at the current BufMut position and of
|
||||
/// length between 0 and `BufMut::remaining()`.
|
||||
///
|
||||
/// The returned byte slice may represent uninitialized memory.
|
||||
unsafe fn bytes_mut(&mut self) -> &mut [u8];
|
||||
|
||||
/// Copies bytes from `src` into `self`
|
||||
///
|
||||
/// # Panics
|
||||
///
|
||||
/// Panics if `self` does not have enough capacity to copy all the data
|
||||
/// from `src`
|
||||
fn copy_from<S: Source>(&mut self, src: S) where Self: Sized {
|
||||
src.source(self);
|
||||
}
|
||||
|
||||
/// Copies bytes from the given slice into the `BufMut` and advance the
|
||||
/// cursor by the number of bytes written.
|
||||
/// Returns the number of bytes written.
|
||||
///
|
||||
/// ```
|
||||
/// use bytes::BufMut;
|
||||
/// use std::io::Cursor;
|
||||
///
|
||||
/// let mut dst = [0; 6];
|
||||
///
|
||||
/// {
|
||||
/// let mut buf = Cursor::new(&mut dst);
|
||||
/// buf.copy_from_slice(b"hello");
|
||||
///
|
||||
/// assert_eq!(1, buf.remaining_mut());
|
||||
/// }
|
||||
///
|
||||
/// assert_eq!(b"hello\0", &dst);
|
||||
/// ```
|
||||
fn copy_from_slice(&mut self, src: &[u8]) {
|
||||
let mut off = 0;
|
||||
|
||||
assert!(self.remaining_mut() >= src.len(), "buffer overflow");
|
||||
|
||||
while off < src.len() {
|
||||
let cnt;
|
||||
|
||||
unsafe {
|
||||
let dst = self.bytes_mut();
|
||||
cnt = cmp::min(dst.len(), src.len() - off);
|
||||
|
||||
ptr::copy_nonoverlapping(
|
||||
src[off..].as_ptr(),
|
||||
dst.as_mut_ptr(),
|
||||
cnt);
|
||||
|
||||
off += cnt;
|
||||
|
||||
}
|
||||
|
||||
unsafe { self.advance_mut(cnt); }
|
||||
}
|
||||
}
|
||||
|
||||
/// Writes the given string into self.
|
||||
///
|
||||
/// # Panics
|
||||
///
|
||||
/// The function panics if `self` does not have enough remaining capacity
|
||||
/// to write the full string.
|
||||
fn put_str(&mut self, src: &str) {
|
||||
self.copy_from_slice(src.as_bytes());
|
||||
}
|
||||
|
||||
/// Writes an unsigned 8 bit integer to the BufMut.
|
||||
fn put_u8(&mut self, n: u8) {
|
||||
self.copy_from_slice(&[n])
|
||||
}
|
||||
|
||||
/// Writes a signed 8 bit integer to the BufMut.
|
||||
fn put_i8(&mut self, n: i8) {
|
||||
self.copy_from_slice(&[n as u8])
|
||||
}
|
||||
|
||||
/// Writes an unsigned 16 bit integer to the BufMut.
|
||||
fn put_u16<T: ByteOrder>(&mut self, n: u16) {
|
||||
let mut buf = [0; 2];
|
||||
T::write_u16(&mut buf, n);
|
||||
self.copy_from_slice(&buf)
|
||||
}
|
||||
|
||||
/// Writes a signed 16 bit integer to the BufMut.
|
||||
fn put_i16<T: ByteOrder>(&mut self, n: i16) {
|
||||
let mut buf = [0; 2];
|
||||
T::write_i16(&mut buf, n);
|
||||
self.copy_from_slice(&buf)
|
||||
}
|
||||
|
||||
/// Writes an unsigned 32 bit integer to the BufMut.
|
||||
fn put_u32<T: ByteOrder>(&mut self, n: u32) {
|
||||
let mut buf = [0; 4];
|
||||
T::write_u32(&mut buf, n);
|
||||
self.copy_from_slice(&buf)
|
||||
}
|
||||
|
||||
/// Writes a signed 32 bit integer to the BufMut.
|
||||
fn put_i32<T: ByteOrder>(&mut self, n: i32) {
|
||||
let mut buf = [0; 4];
|
||||
T::write_i32(&mut buf, n);
|
||||
self.copy_from_slice(&buf)
|
||||
}
|
||||
|
||||
/// Writes an unsigned 64 bit integer to the BufMut.
|
||||
fn put_u64<T: ByteOrder>(&mut self, n: u64) {
|
||||
let mut buf = [0; 8];
|
||||
T::write_u64(&mut buf, n);
|
||||
self.copy_from_slice(&buf)
|
||||
}
|
||||
|
||||
/// Writes a signed 64 bit integer to the BufMut.
|
||||
fn put_i64<T: ByteOrder>(&mut self, n: i64) {
|
||||
let mut buf = [0; 8];
|
||||
T::write_i64(&mut buf, n);
|
||||
self.copy_from_slice(&buf)
|
||||
}
|
||||
|
||||
/// Writes an unsigned n-bytes integer to the BufMut.
|
||||
///
|
||||
/// If the given integer is not representable in the given number of bytes,
|
||||
/// this method panics. If `nbytes > 8`, this method panics.
|
||||
fn put_uint<T: ByteOrder>(&mut self, n: u64, nbytes: usize) {
|
||||
let mut buf = [0; 8];
|
||||
T::write_uint(&mut buf, n, nbytes);
|
||||
self.copy_from_slice(&buf[0..nbytes])
|
||||
}
|
||||
|
||||
/// Writes a signed n-bytes integer to the BufMut.
|
||||
///
|
||||
/// If the given integer is not representable in the given number of bytes,
|
||||
/// this method panics. If `nbytes > 8`, this method panics.
|
||||
fn put_int<T: ByteOrder>(&mut self, n: i64, nbytes: usize) {
|
||||
let mut buf = [0; 8];
|
||||
T::write_int(&mut buf, n, nbytes);
|
||||
self.copy_from_slice(&buf[0..nbytes])
|
||||
}
|
||||
|
||||
/// Writes a IEEE754 single-precision (4 bytes) floating point number to
|
||||
/// the BufMut.
|
||||
fn put_f32<T: ByteOrder>(&mut self, n: f32) {
|
||||
let mut buf = [0; 4];
|
||||
T::write_f32(&mut buf, n);
|
||||
self.copy_from_slice(&buf)
|
||||
}
|
||||
|
||||
/// Writes a IEEE754 double-precision (8 bytes) floating point number to
|
||||
/// the BufMut.
|
||||
fn put_f64<T: ByteOrder>(&mut self, n: f64) {
|
||||
let mut buf = [0; 8];
|
||||
T::write_f64(&mut buf, n);
|
||||
self.copy_from_slice(&buf)
|
||||
}
|
||||
|
||||
/// Creates a "by reference" adaptor for this instance of BufMut
|
||||
fn by_ref(&mut self) -> &mut Self where Self: Sized {
|
||||
self
|
||||
}
|
||||
|
||||
/// Create an adapter which will limit at most `limit` bytes from it.
|
||||
fn take_mut(self, limit: usize) -> TakeMut<Self> where Self: Sized {
|
||||
take::new_mut(self, limit)
|
||||
}
|
||||
|
||||
/// Return a `Write` for the value. Allows using a `BufMut` as an
|
||||
/// `io::Write`
|
||||
fn writer(self) -> Writer<Self> where Self: Sized {
|
||||
Writer::new(self)
|
||||
}
|
||||
}
|
||||
|
||||
/*
|
||||
*
|
||||
* ===== IntoBuf =====
|
||||
*
|
||||
*/
|
||||
|
||||
/// Conversion into a `Buf`
|
||||
///
|
||||
/// Usually, `IntoBuf` is implemented on references of types and not directly
|
||||
/// on the types themselves. For example, `IntoBuf` is implemented for `&'a
|
||||
/// Vec<u8>` and not `Vec<u8>` directly.
|
||||
pub trait IntoBuf {
|
||||
/// The `Buf` type that `self` is being converted into
|
||||
type Buf: Buf;
|
||||
|
||||
/// Creates a `Buf` from a value.
|
||||
fn into_buf(self) -> Self::Buf;
|
||||
}
|
||||
|
||||
impl<'a> IntoBuf for &'a [u8] {
|
||||
type Buf = io::Cursor<&'a [u8]>;
|
||||
|
||||
/// Creates a buffer from a value
|
||||
fn into_buf(self) -> Self::Buf {
|
||||
io::Cursor::new(self)
|
||||
}
|
||||
}
|
||||
|
||||
// Kind of annoying...
|
||||
impl<'a> IntoBuf for &'a &'static [u8] {
|
||||
type Buf = io::Cursor<&'static [u8]>;
|
||||
|
||||
/// Creates a buffer from a value
|
||||
fn into_buf(self) -> Self::Buf {
|
||||
io::Cursor::new(self)
|
||||
}
|
||||
}
|
||||
|
||||
impl IntoBuf for Vec<u8> {
|
||||
type Buf = io::Cursor<Vec<u8>>;
|
||||
|
||||
fn into_buf(self) -> Self::Buf {
|
||||
io::Cursor::new(self)
|
||||
}
|
||||
}
|
||||
|
||||
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 () {
|
||||
type Buf = io::Cursor<&'static [u8]>;
|
||||
|
||||
fn into_buf(self) -> Self::Buf {
|
||||
io::Cursor::new(&[])
|
||||
}
|
||||
}
|
||||
|
||||
impl<'a> IntoBuf for &'a () {
|
||||
type Buf = io::Cursor<&'static [u8]>;
|
||||
|
||||
fn into_buf(self) -> Self::Buf {
|
||||
io::Cursor::new(&[])
|
||||
}
|
||||
}
|
||||
|
||||
/*
|
||||
*
|
||||
* ===== Sink / Source =====
|
||||
*
|
||||
*/
|
||||
|
||||
|
||||
/// A value that writes bytes from itself into a `BufMut`.
|
||||
pub trait Source {
|
||||
/// Copy data from self into destination buffer
|
||||
fn source<B: BufMut>(self, buf: &mut B);
|
||||
}
|
||||
|
||||
impl<'a> Source for &'a [u8] {
|
||||
fn source<B: BufMut>(self, buf: &mut B) {
|
||||
buf.copy_from_slice(self);
|
||||
}
|
||||
}
|
||||
|
||||
impl Source for u8 {
|
||||
fn source<B: BufMut>(self, buf: &mut B) {
|
||||
let src = [self];
|
||||
buf.copy_from_slice(&src);
|
||||
}
|
||||
}
|
||||
|
||||
impl Source for Bytes {
|
||||
fn source<B: BufMut>(self, buf: &mut B) {
|
||||
Source::source(self.as_ref(), buf);
|
||||
}
|
||||
}
|
||||
|
||||
impl<'a> Source for &'a Bytes {
|
||||
fn source<B: BufMut>(self, buf: &mut B) {
|
||||
Source::source(self.as_ref(), buf);
|
||||
}
|
||||
}
|
||||
|
||||
impl<'a, T: Buf> Source for &'a mut T {
|
||||
fn source<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); }
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
/// A value that copies bytes from a `Buf` into itself
|
||||
pub trait Sink {
|
||||
/// Copy bytes from `buf` into `self`
|
||||
fn sink<B: Buf>(&mut self, buf: &mut B);
|
||||
}
|
||||
|
||||
impl Sink for [u8] {
|
||||
fn sink<B: Buf>(&mut self, buf: &mut B) {
|
||||
buf.copy_to_slice(self);
|
||||
}
|
||||
}
|
||||
|
||||
impl<T: BufMut> Sink for T {
|
||||
fn sink<B: Buf>(&mut self, buf: &mut B) {
|
||||
Source::source(buf, self)
|
||||
}
|
||||
}
|
||||
|
||||
/*
|
||||
*
|
||||
* ===== Read / Write =====
|
||||
*
|
||||
*/
|
||||
|
||||
/// Adapts a `Buf` to the `io::Read` trait
|
||||
pub struct Reader<B> {
|
||||
buf: B,
|
||||
}
|
||||
|
||||
impl<B: Buf> Reader<B> {
|
||||
/// Return a `Reader` for the given `buf`
|
||||
pub fn new(buf: B) -> Reader<B> {
|
||||
Reader { buf: buf }
|
||||
}
|
||||
|
||||
/// Gets a reference to the underlying buf.
|
||||
pub fn get_ref(&self) -> &B {
|
||||
&self.buf
|
||||
}
|
||||
|
||||
/// Gets a mutable reference to the underlying buf.
|
||||
pub fn get_mut(&mut self) -> &mut B {
|
||||
&mut self.buf
|
||||
}
|
||||
|
||||
/// Unwraps this `Reader`, returning the underlying `Buf`
|
||||
pub fn into_inner(self) -> B {
|
||||
self.buf
|
||||
}
|
||||
}
|
||||
|
||||
impl<B: Buf + Sized> io::Read for Reader<B> {
|
||||
fn read(&mut self, dst: &mut [u8]) -> io::Result<usize> {
|
||||
let len = cmp::min(self.buf.remaining(), dst.len());
|
||||
|
||||
Buf::copy_to(&mut self.buf, &mut dst[0..len]);
|
||||
Ok(len)
|
||||
}
|
||||
}
|
||||
|
||||
/// Adapts a `BufMut` to the `io::Write` trait
|
||||
pub struct Writer<B> {
|
||||
buf: B,
|
||||
}
|
||||
|
||||
impl<B: BufMut> Writer<B> {
|
||||
/// Return a `Writer` for teh given `buf`
|
||||
pub fn new(buf: B) -> Writer<B> {
|
||||
Writer { buf: buf }
|
||||
}
|
||||
|
||||
/// Gets a reference to the underlying buf.
|
||||
pub fn get_ref(&self) -> &B {
|
||||
&self.buf
|
||||
}
|
||||
|
||||
/// Gets a mutable reference to the underlying buf.
|
||||
pub fn get_mut(&mut self) -> &mut B {
|
||||
&mut self.buf
|
||||
}
|
||||
|
||||
/// Unwraps this `Writer`, returning the underlying `BufMut`
|
||||
pub fn into_inner(self) -> B {
|
||||
self.buf
|
||||
}
|
||||
}
|
||||
|
||||
impl<B: BufMut + Sized> io::Write for Writer<B> {
|
||||
fn write(&mut self, src: &[u8]) -> io::Result<usize> {
|
||||
let n = cmp::min(self.buf.remaining_mut(), src.len());
|
||||
|
||||
self.buf.copy_from(&src[0..n]);
|
||||
Ok(n)
|
||||
}
|
||||
|
||||
fn flush(&mut self) -> io::Result<()> {
|
||||
Ok(())
|
||||
}
|
||||
}
|
||||
|
||||
/*
|
||||
*
|
||||
* ===== Buf impls =====
|
||||
*
|
||||
*/
|
||||
|
||||
impl<'a, T: Buf> Buf for &'a mut T {
|
||||
fn remaining(&self) -> usize {
|
||||
(**self).remaining()
|
||||
}
|
||||
|
||||
fn bytes(&self) -> &[u8] {
|
||||
(**self).bytes()
|
||||
}
|
||||
|
||||
fn advance(&mut self, cnt: usize) {
|
||||
(**self).advance(cnt)
|
||||
}
|
||||
}
|
||||
|
||||
impl<'a, T: BufMut> BufMut for &'a mut T {
|
||||
fn remaining_mut(&self) -> usize {
|
||||
(**self).remaining_mut()
|
||||
}
|
||||
|
||||
unsafe fn bytes_mut(&mut self) -> &mut [u8] {
|
||||
(**self).bytes_mut()
|
||||
}
|
||||
|
||||
unsafe fn advance_mut(&mut self, cnt: usize) {
|
||||
(**self).advance_mut(cnt)
|
||||
}
|
||||
}
|
||||
|
||||
impl<T: AsRef<[u8]>> Buf for io::Cursor<T> {
|
||||
fn remaining(&self) -> usize {
|
||||
let len = self.get_ref().as_ref().len();
|
||||
let pos = self.position();
|
||||
|
||||
if pos >= len as u64 {
|
||||
return 0;
|
||||
}
|
||||
|
||||
len - pos as usize
|
||||
}
|
||||
|
||||
fn bytes(&self) -> &[u8] {
|
||||
let pos = self.position() as usize;
|
||||
&(self.get_ref().as_ref())[pos..]
|
||||
}
|
||||
|
||||
fn advance(&mut self, cnt: usize) {
|
||||
let pos = self.position() as usize;
|
||||
let pos = cmp::min(self.get_ref().as_ref().len(), pos + cnt);
|
||||
self.set_position(pos as u64);
|
||||
}
|
||||
}
|
||||
|
||||
impl<T: AsMut<[u8]> + AsRef<[u8]>> BufMut for io::Cursor<T> {
|
||||
fn remaining_mut(&self) -> usize {
|
||||
self.remaining()
|
||||
}
|
||||
|
||||
/// Advance the internal cursor of the BufMut
|
||||
unsafe fn advance_mut(&mut self, cnt: usize) {
|
||||
let pos = self.position() as usize;
|
||||
let pos = cmp::min(self.get_mut().as_mut().len(), pos + cnt);
|
||||
self.set_position(pos as u64);
|
||||
}
|
||||
|
||||
/// Returns a mutable slice starting at the current BufMut position and of
|
||||
/// length between 0 and `BufMut::remaining()`.
|
||||
///
|
||||
/// The returned byte slice may represent uninitialized memory.
|
||||
unsafe fn bytes_mut(&mut self) -> &mut [u8] {
|
||||
let pos = self.position() as usize;
|
||||
&mut (self.get_mut().as_mut())[pos..]
|
||||
}
|
||||
}
|
||||
|
||||
impl BufMut for Vec<u8> {
|
||||
fn remaining_mut(&self) -> usize {
|
||||
usize::MAX - self.len()
|
||||
}
|
||||
|
||||
unsafe fn advance_mut(&mut self, cnt: usize) {
|
||||
let len = self.len() + cnt;
|
||||
|
||||
if len > self.capacity() {
|
||||
// Reserve additional
|
||||
// TODO: Should this case panic?
|
||||
let cap = self.capacity();
|
||||
self.reserve(cap - len);
|
||||
}
|
||||
|
||||
self.set_len(len);
|
||||
}
|
||||
|
||||
unsafe fn bytes_mut(&mut self) -> &mut [u8] {
|
||||
use std::slice;
|
||||
|
||||
if self.capacity() == self.len() {
|
||||
self.reserve(64); // Grow the vec
|
||||
}
|
||||
|
||||
let cap = self.capacity();
|
||||
let len = self.len();
|
||||
|
||||
let ptr = self.as_mut_ptr();
|
||||
&mut slice::from_raw_parts_mut(ptr, cap)[len..]
|
||||
}
|
||||
}
|
||||
@@ -0,0 +1,139 @@
|
||||
//! A buffer backed by a contiguous region of memory.
|
||||
|
||||
use {Buf, BufMut};
|
||||
use std::fmt;
|
||||
|
||||
/*
|
||||
*
|
||||
* ===== SliceBuf =====
|
||||
*
|
||||
*/
|
||||
|
||||
/// A `Buf` backed by a contiguous region of memory.
|
||||
///
|
||||
/// This `Buf` is better suited for cases where there is a clear delineation
|
||||
/// between reading and writing.
|
||||
pub struct SliceBuf<T = Box<[u8]>> {
|
||||
// Contiguous memory
|
||||
mem: T,
|
||||
// Current read position
|
||||
rd: usize,
|
||||
// Current write position
|
||||
wr: usize,
|
||||
}
|
||||
|
||||
impl<T: AsRef<[u8]>> SliceBuf<T> {
|
||||
/// Creates a new `SliceBuf` wrapping the provided slice
|
||||
pub fn new(mem: T) -> SliceBuf<T> {
|
||||
SliceBuf {
|
||||
mem: mem,
|
||||
rd: 0,
|
||||
wr: 0,
|
||||
}
|
||||
}
|
||||
|
||||
/// Return the number of bytes the buffer can contain
|
||||
pub fn capacity(&self) -> usize {
|
||||
self.mem.as_ref().len()
|
||||
}
|
||||
|
||||
/// Return the read cursor position
|
||||
pub fn position(&self) -> usize {
|
||||
self.rd
|
||||
}
|
||||
|
||||
/// Set the read cursor position
|
||||
pub fn set_position(&mut self, position: usize) {
|
||||
assert!(position <= self.wr, "position out of bounds");
|
||||
self.rd = position
|
||||
}
|
||||
|
||||
/// Return the number of buffered bytes
|
||||
pub fn len(&self) -> usize {
|
||||
self.wr
|
||||
}
|
||||
|
||||
/// Returns `true` if the buffer contains no unread bytes
|
||||
pub fn is_empty(&self) -> bool {
|
||||
self.len() == 0
|
||||
}
|
||||
|
||||
/// Clears the buffer, removing any written data
|
||||
pub fn clear(&mut self) {
|
||||
self.rd = 0;
|
||||
self.wr = 0;
|
||||
}}
|
||||
|
||||
impl<T> Buf for SliceBuf<T>
|
||||
where T: AsRef<[u8]>,
|
||||
{
|
||||
fn remaining(&self) -> usize {
|
||||
self.wr - self.rd
|
||||
}
|
||||
|
||||
fn bytes(&self) -> &[u8] {
|
||||
&self.mem.as_ref()[self.rd..self.wr]
|
||||
}
|
||||
|
||||
fn advance(&mut self, cnt: usize) {
|
||||
assert!(cnt <= self.remaining(), "buffer overflow");
|
||||
self.rd += cnt;
|
||||
}
|
||||
|
||||
fn copy_to_slice(&mut self, dst: &mut [u8]) {
|
||||
assert!(self.remaining() >= dst.len());
|
||||
|
||||
let len = dst.len();
|
||||
dst.copy_from_slice(&self.mem.as_ref()[self.rd..self.rd+len]);
|
||||
self.rd += len;
|
||||
}
|
||||
}
|
||||
|
||||
impl<T> BufMut for SliceBuf<T>
|
||||
where T: AsRef<[u8]> + AsMut<[u8]>,
|
||||
{
|
||||
fn remaining_mut(&self) -> usize {
|
||||
self.capacity() - self.wr
|
||||
}
|
||||
|
||||
unsafe fn advance_mut(&mut self, cnt: usize) {
|
||||
assert!(cnt <= self.remaining_mut());
|
||||
self.wr += cnt;
|
||||
}
|
||||
|
||||
unsafe fn bytes_mut(&mut self) -> &mut [u8] {
|
||||
&mut self.mem.as_mut()[self.wr..]
|
||||
}
|
||||
|
||||
fn copy_from_slice(&mut self, src: &[u8]) {
|
||||
assert!(self.remaining_mut() >= src.len());
|
||||
|
||||
let wr = self.wr;
|
||||
|
||||
self.mem.as_mut()[wr..wr+src.len()]
|
||||
.copy_from_slice(src);
|
||||
|
||||
self.wr += src.len();
|
||||
}
|
||||
}
|
||||
|
||||
impl<T> fmt::Debug for SliceBuf<T>
|
||||
where T: AsRef<[u8]>,
|
||||
{
|
||||
fn fmt(&self, fmt: &mut fmt::Formatter) -> fmt::Result {
|
||||
self.bytes().fmt(fmt)
|
||||
}
|
||||
}
|
||||
|
||||
impl<T> fmt::Write for SliceBuf<T>
|
||||
where T: AsRef<[u8]> + AsMut<[u8]>
|
||||
{
|
||||
fn write_str(&mut self, s: &str) -> fmt::Result {
|
||||
BufMut::put_str(self, s);
|
||||
Ok(())
|
||||
}
|
||||
|
||||
fn write_fmt(&mut self, args: fmt::Arguments) -> fmt::Result {
|
||||
fmt::write(self, args)
|
||||
}
|
||||
}
|
||||
+182
@@ -0,0 +1,182 @@
|
||||
use {Buf, BufMut};
|
||||
use std::{cmp, fmt};
|
||||
|
||||
/// A buffer adapter which limits the bytes read from an underlying value.
|
||||
#[derive(Debug)]
|
||||
pub struct Take<T> {
|
||||
inner: T,
|
||||
limit: usize,
|
||||
}
|
||||
|
||||
/// A buffer adapter which limits the bytes written from an underlying value.
|
||||
#[derive(Debug)]
|
||||
pub struct TakeMut<T> {
|
||||
inner: T,
|
||||
limit: usize,
|
||||
}
|
||||
|
||||
pub fn new<T>(inner: T, limit: usize) -> Take<T> {
|
||||
Take {
|
||||
inner: inner,
|
||||
limit: limit,
|
||||
}
|
||||
}
|
||||
|
||||
pub fn new_mut<T>(inner: T, limit: usize) -> TakeMut<T> {
|
||||
TakeMut {
|
||||
inner: inner,
|
||||
limit: limit,
|
||||
}
|
||||
}
|
||||
|
||||
/*
|
||||
*
|
||||
* ===== impl Take =====
|
||||
*
|
||||
*/
|
||||
|
||||
impl<T> Take<T> {
|
||||
/// Consumes this `Take`, returning the underlying value.
|
||||
pub fn into_inner(self) -> T {
|
||||
self.inner
|
||||
}
|
||||
|
||||
/// Gets a reference to the underlying value in this `Take`.
|
||||
pub fn get_ref(&self) -> &T {
|
||||
&self.inner
|
||||
}
|
||||
|
||||
/// Gets a mutable reference to the underlying value in this `Take`.
|
||||
pub fn get_mut(&mut self) -> &mut T {
|
||||
&mut self.inner
|
||||
}
|
||||
|
||||
/// Returns the maximum number of bytes that are made available from the
|
||||
/// underlying value.
|
||||
pub fn limit(&self) -> usize {
|
||||
self.limit
|
||||
}
|
||||
|
||||
/// Sets the maximum number of bytes that are made available from the
|
||||
/// underlying value.
|
||||
pub fn set_limit(&mut self, lim: usize) {
|
||||
self.limit = lim
|
||||
}
|
||||
}
|
||||
|
||||
impl<T: Buf> Buf for Take<T> {
|
||||
fn remaining(&self) -> usize {
|
||||
cmp::min(self.inner.remaining(), self.limit)
|
||||
}
|
||||
|
||||
fn bytes(&self) -> &[u8] {
|
||||
&self.inner.bytes()[..self.limit]
|
||||
}
|
||||
|
||||
fn advance(&mut self, cnt: usize) {
|
||||
let cnt = cmp::min(cnt, self.limit);
|
||||
self.limit -= cnt;
|
||||
self.inner.advance(cnt);
|
||||
}
|
||||
}
|
||||
|
||||
impl<T: BufMut> BufMut for Take<T> {
|
||||
fn remaining_mut(&self) -> usize {
|
||||
self.inner.remaining_mut()
|
||||
}
|
||||
|
||||
unsafe fn bytes_mut(&mut self) -> &mut [u8] {
|
||||
self.inner.bytes_mut()
|
||||
}
|
||||
|
||||
unsafe fn advance_mut(&mut self, cnt: usize) {
|
||||
self.inner.advance_mut(cnt)
|
||||
}
|
||||
}
|
||||
|
||||
impl<T: BufMut> fmt::Write for Take<T> {
|
||||
fn write_str(&mut self, s: &str) -> fmt::Result {
|
||||
BufMut::put_str(self, s);
|
||||
Ok(())
|
||||
}
|
||||
|
||||
fn write_fmt(&mut self, args: fmt::Arguments) -> fmt::Result {
|
||||
fmt::write(self, args)
|
||||
}
|
||||
}
|
||||
|
||||
/*
|
||||
*
|
||||
* ===== impl TakeMut =====
|
||||
*
|
||||
*/
|
||||
|
||||
impl<T> TakeMut<T> {
|
||||
/// Consumes this `TakeMut`, returning the underlying value.
|
||||
pub fn into_inner(self) -> T {
|
||||
self.inner
|
||||
}
|
||||
|
||||
/// Gets a reference to the underlying value in this `TakeMut`.
|
||||
pub fn get_ref(&self) -> &T {
|
||||
&self.inner
|
||||
}
|
||||
|
||||
/// Gets a mutable reference to the underlying value in this `TakeMut`.
|
||||
pub fn get_mut(&mut self) -> &mut T {
|
||||
&mut self.inner
|
||||
}
|
||||
|
||||
/// Returns the maximum number of bytes that are made available from the
|
||||
/// underlying value.
|
||||
pub fn limit(&self) -> usize {
|
||||
self.limit
|
||||
}
|
||||
|
||||
/// Sets the maximum number of bytes that are made available from the
|
||||
/// underlying value.
|
||||
pub fn set_limit(&mut self, lim: usize) {
|
||||
self.limit = lim
|
||||
}
|
||||
}
|
||||
|
||||
impl<T: Buf> Buf for TakeMut<T> {
|
||||
fn remaining(&self) -> usize {
|
||||
self.inner.remaining()
|
||||
}
|
||||
|
||||
fn bytes(&self) -> &[u8] {
|
||||
self.inner.bytes()
|
||||
}
|
||||
|
||||
fn advance(&mut self, cnt: usize) {
|
||||
self.inner.advance(cnt)
|
||||
}
|
||||
}
|
||||
|
||||
impl<T: BufMut> BufMut for TakeMut<T> {
|
||||
fn remaining_mut(&self) -> usize {
|
||||
cmp::min(self.inner.remaining_mut(), self.limit)
|
||||
}
|
||||
|
||||
unsafe fn bytes_mut(&mut self) -> &mut [u8] {
|
||||
&mut self.inner.bytes_mut()[..self.limit]
|
||||
}
|
||||
|
||||
unsafe fn advance_mut(&mut self, cnt: usize) {
|
||||
let cnt = cmp::min(cnt, self.limit);
|
||||
self.limit -= cnt;
|
||||
self.inner.advance_mut(cnt);
|
||||
}
|
||||
}
|
||||
|
||||
impl<T: BufMut> fmt::Write for TakeMut<T> {
|
||||
fn write_str(&mut self, s: &str) -> fmt::Result {
|
||||
BufMut::put_str(self, s);
|
||||
Ok(())
|
||||
}
|
||||
|
||||
fn write_fmt(&mut self, args: fmt::Arguments) -> fmt::Result {
|
||||
fmt::write(self, args)
|
||||
}
|
||||
}
|
||||
Reference in New Issue
Block a user