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

Huge overhaul of bytes

Browse Source 
* Get rid of `ByteStr` trait
* `Bytes` is not a concrete type
* Add `BlockBuf`
* Delete lots of cruft
* Performance work
This commit is contained in:
Carl Lerche
2016-08-10 15:45:31 -07:00
parent b2efe63c70
commit 04e0ac75e2
31 changed files with 1630 additions and 1653 deletions
Download Patch File Download Diff File Expand all files Collapse all files
Cargo.toml
+1
View File
@@ -20,6 +20,7 @@ exclude = [
[dependencies]
stable-heap = { git = "https://github.com/carllerche/stable-heap", rev = "3c5cd1ca47" }
log = "0.3.6"
[dev-dependencies]
rand = "0.3.5"
bench/bench.rs
+27 -12
View File
@@ -1,34 +1,49 @@
#![feature(test, core)]
#![feature(test)]
use bytes::ByteBuf;
use bytes::traits::*;
use iobuf::{RWIobuf};
use bytes::alloc::Pool;
use test::Bencher;
use std::sync::Arc;
extern crate bytes;
extern crate iobuf;
extern crate test;
const SIZE:usize = 4_096;
#[bench]
pub fn bench_byte_buf_fill_4kb(b: &mut Bencher) {
pub fn bench_allocate_arc_vec(b: &mut Bencher) {
b.iter(|| {
let mut buf = ByteBuf::mut_with_capacity(SIZE);
let mut v = Vec::with_capacity(200);
for _ in 0..SIZE {
buf.write_slice(&[0]);
for _ in 0..200 {
let buf = Arc::new(Vec::<u8>::with_capacity(SIZE));
v.push(buf);
}
});
}
#[bench]
pub fn bench_rw_iobuf_fill_4kb(b: &mut Bencher) {
pub fn bench_allocate_byte_buf(b: &mut Bencher) {
b.iter(|| {
let mut buf = RWIobuf::new(SIZE);
let mut v = Vec::with_capacity(200);
for _ in 0..SIZE {
let _ = buf.fill(&[0]);
for _ in 0..200 {
let buf = ByteBuf::mut_with_capacity(SIZE);
v.push(buf);
}
});
}
#[bench]
pub fn bench_allocate_with_pool(b: &mut Bencher) {
let mut pool = Pool::with_capacity(1_024, SIZE);
b.iter(|| {
let mut v = Vec::with_capacity(200);
for _ in 0..200 {
let buf = pool.new_byte_buf();
v.push(buf);
}
})
}
src/alloc/heap.rs
+29 -32
View File
@@ -6,44 +6,41 @@ use std::sync::atomic::{self, AtomicUsize, Ordering};
const MAX_ALLOC_SIZE: usize = usize::MAX;
const MAX_REFCOUNT: usize = (isize::MAX) as usize;
pub struct Heap;
/// Tracks a heap allocation and stores the atomic ref counter
struct Allocation {
refs: AtomicUsize,
}
impl Heap {
pub fn allocate(&self, len: usize) -> MemRef {
// Make sure that the allocation is within the permitted range
if len > MAX_ALLOC_SIZE {
return MemRef::none();
}
unsafe {
let mut ptr = heap::allocate(alloc_len(len), align());
let mut off = 0;
ptr::write(ptr as *mut Allocation, Allocation::new());
off += mem::size_of::<Allocation>();
ptr::write(ptr.offset(off as isize) as *mut &Mem, &*(ptr as *const Allocation));
off += mem::size_of::<&Mem>();
ptr::write(ptr.offset(off as isize) as *mut usize, len);
ptr = ptr.offset(mem::size_of::<Allocation>() as isize);
MemRef::new(ptr)
}
pub fn allocate(len: usize) -> MemRef {
// Make sure that the allocation is within the permitted range
if len > MAX_ALLOC_SIZE {
return MemRef::none();
}
fn deallocate(ptr: *mut u8) {
unsafe {
let off = mem::size_of::<Allocation>() + mem::size_of::<&Mem>();
let len = ptr::read(ptr.offset(off as isize) as *const usize);
unsafe {
let mut ptr = heap::allocate(alloc_len(len), align());
let mut off = 0;
heap::deallocate(ptr, alloc_len(len), align());
}
ptr::write(ptr as *mut Allocation, Allocation::new());
off += mem::size_of::<Allocation>();
ptr::write(ptr.offset(off as isize) as *mut &Mem, &*(ptr as *const Allocation));
off += mem::size_of::<&Mem>();
ptr::write(ptr.offset(off as isize) as *mut usize, len);
ptr = ptr.offset(mem::size_of::<Allocation>() as isize);
MemRef::new(ptr)
}
}
fn deallocate(ptr: *mut u8) {
unsafe {
let off = mem::size_of::<Allocation>() + mem::size_of::<&Mem>();
let len = ptr::read(ptr.offset(off as isize) as *const usize);
heap::deallocate(ptr, alloc_len(len), align());
}
}
@@ -90,7 +87,7 @@ impl Mem for Allocation {
}
atomic::fence(Ordering::Acquire);
Heap::deallocate(self as *const Allocation as *const u8 as *mut u8);
deallocate(self as *const Allocation as *const u8 as *mut u8);
}
}
src/alloc/mod.rs
+22 -6
View File
@@ -1,15 +1,11 @@
mod heap;
mod pool;
pub use self::heap::Heap;
pub use self::pool::Pool;
use std::{mem, ptr};
pub fn heap(len: usize) -> MemRef {
Heap.allocate(len)
}
/// Ref-counted segment of memory
pub trait Mem: Send + Sync {
/// Increment the ref count
fn ref_inc(&self);
@@ -27,6 +23,11 @@ pub struct MemRef {
ptr: *mut u8,
}
/// Allocate a segment of memory and return a `MemRef`.
pub fn heap(len: usize) -> MemRef {
heap::allocate(len)
}
impl MemRef {
#[inline]
pub unsafe fn new(ptr: *mut u8) -> MemRef {
@@ -55,11 +56,26 @@ impl MemRef {
}
#[inline]
pub unsafe fn bytes_mut(&mut self) -> &mut [u8] {
pub unsafe fn bytes_slice(&self, start: usize, end: usize) -> &[u8] {
use std::slice;
let ptr = self.bytes_ptr().offset(start as isize);
slice::from_raw_parts(ptr, end - start)
}
#[inline]
pub unsafe fn mut_bytes(&mut self) -> &mut [u8] {
use std::slice;
slice::from_raw_parts_mut(self.bytes_ptr(), self.len())
}
/// Unsafe, unchecked access to the bytes
#[inline]
pub unsafe fn mut_bytes_slice(&mut self, start: usize, end: usize) -> &mut [u8] {
use std::slice;
let ptr = self.bytes_ptr().offset(start as isize);
slice::from_raw_parts_mut(ptr, end - start)
}
#[inline]
fn mem(&self) -> &Mem {
unsafe {
src/alloc/pool.rs
+8 -1
View File
@@ -1,5 +1,5 @@
use {AppendBuf, ByteBuf, MutByteBuf};
use super::{Mem, MemRef};
use buf::{AppendBuf, ByteBuf, MutByteBuf};
use stable_heap as heap;
use std::{mem, ptr, isize, usize};
use std::cell::{Cell, UnsafeCell};
@@ -78,10 +78,17 @@ impl Pool {
}
/// Returns the number of buffers that the `Pool` holds.
#[inline]
pub fn capacity(&self) -> usize {
self.inner.cap
}
/// Returns the size of buffers allocated by the pool
#[inline]
pub fn buffer_len(&self) -> usize {
self.inner.buf_len
}
/// Returns a new `ByteBuf` backed by a buffer from the pool. If the pool
/// is depleted, `None` is returned.
pub fn new_byte_buf(&self) -> Option<MutByteBuf> {
src/buf/append.rs
+40 -21
View File
@@ -1,8 +1,7 @@
use alloc;
use buf::{MutBuf};
use str::{ByteStr, Bytes, SeqByteStr, SmallByteStr};
use bytes::Bytes;
use std::cell::Cell;
use std::cmp;
/// A `Buf` backed by a contiguous region of memory.
///
@@ -33,12 +32,7 @@ impl AppendBuf {
return AppendBuf::none();
}
AppendBuf {
mem: mem,
rd: Cell::new(0),
wr: 0,
cap: capacity,
}
unsafe { AppendBuf::from_mem_ref(mem, capacity, 0) }
}
/// Returns an AppendBuf with no capacity
@@ -60,10 +54,20 @@ impl AppendBuf {
}
}
#[inline]
pub fn len(&self) -> usize {
(self.wr - self.rd.get()) as usize
}
#[inline]
pub fn capacity(&self) -> usize {
(self.cap - self.rd.get()) as usize
}
pub fn bytes(&self) -> &[u8] {
let rd = self.rd.get() as usize;
let wr = self.wr as usize;
unsafe { &self.mem.bytes()[rd..wr] }
unsafe { &self.mem.bytes_slice(rd, wr) }
}
pub fn shift(&self, n: usize) -> Bytes {
@@ -72,29 +76,37 @@ impl AppendBuf {
ret
}
pub fn drop(&self, n: usize) {
assert!(n <= self.len());
self.rd.set(self.rd.get() + n as u32);
}
pub fn slice(&self, begin: usize, end: usize) -> Bytes {
if end <= begin {
return Bytes::of(SmallByteStr::zero());
}
let rd = self.rd.get() as usize;
let wr = self.wr as usize;
if let Some(bytes) = SmallByteStr::from_slice(&self.bytes()[begin..end]) {
return Bytes::of(bytes);
}
assert!(begin <= end && end <= wr - rd, "invalid range");
let begin = cmp::min(self.wr, begin as u32 + self.rd.get());
let end = cmp::min(self.wr, end as u32 + self.rd.get());
let begin = (begin + rd) as u32;
let end = (end + rd) as u32;
let bytes = unsafe { SeqByteStr::from_mem_ref(self.mem.clone(), begin, end - begin) };
Bytes::of(bytes)
unsafe { Bytes::from_mem_ref(self.mem.clone(), begin, end - begin) }
}
}
impl MutBuf for AppendBuf {
#[inline]
fn remaining(&self) -> usize {
(self.cap - self.wr) as usize
}
#[inline]
fn has_remaining(&self) -> bool {
// Implemented as an equality for the perfz
self.cap != self.wr
}
#[inline]
unsafe fn advance(&mut self, cnt: usize) {
self.wr += cnt as u32;
@@ -103,9 +115,16 @@ impl MutBuf for AppendBuf {
}
}
#[inline]
unsafe fn mut_bytes<'a>(&'a mut self) -> &'a mut [u8] {
let wr = self.wr as usize;
let cap = self.cap as usize;
&mut self.mem.bytes_mut()[wr..cap]
self.mem.mut_bytes_slice(wr, cap)
}
}
impl AsRef<[u8]> for AppendBuf {
fn as_ref(&self) -> &[u8] {
self.bytes()
}
}
src/buf/block.rs
+321
View File
@@ -0,0 +1,321 @@
#![allow(warnings)]
use {Buf, MutBuf, AppendBuf, Bytes};
use alloc::{self, Pool};
use std::{cmp, ptr, slice};
use std::io::Cursor;
use std::rc::Rc;
use std::collections::{vec_deque, VecDeque};
/// Append only buffer backed by a chain of `AppendBuf` buffers.
///
/// Each `AppendBuf` block is of a fixed size and allocated on demand. This
/// makes the total capacity of a `BlockBuf` potentially much larger than what
/// is currently allocated.
pub struct BlockBuf {
len: usize,
cap: usize,
blocks: VecDeque<AppendBuf>,
new_block: NewBlock,
}
pub enum NewBlock {
Heap(usize),
Pool(Rc<Pool>),
}
pub struct BlockBufCursor<'a> {
rem: usize,
blocks: vec_deque::Iter<'a, AppendBuf>,
curr: Option<Cursor<&'a [u8]>>,
}
// TODO:
//
// - Add `comapct` fn which moves all buffered data into one block.
// - Add `slice` fn which returns `Bytes` for arbitrary views into the Buf
//
impl BlockBuf {
/// Create BlockBuf
pub fn new(max_blocks: usize, new_block: NewBlock) -> BlockBuf {
assert!(max_blocks > 1, "at least 2 blocks required");
BlockBuf {
len: 0,
cap: max_blocks * new_block.block_size(),
blocks: VecDeque::with_capacity(max_blocks),
new_block: new_block,
}
}
/// Returns the number of buffered bytes
#[inline]
pub fn len(&self) -> usize {
debug_assert!(self.len == self.blocks.iter().map(|b| b.len()).fold(0, |a, b| a+b));
self.len
}
/// Returns true if there are no buffered bytes
#[inline]
pub fn is_empty(&self) -> bool {
return self.len() == 0
}
/// Returns a `Buf` for the currently buffered bytes.
#[inline]
pub fn buf(&self) -> BlockBufCursor {
let mut iter = self.blocks.iter();
// Get the next leaf node buffer
let block = iter.next()
.map(|block| Cursor::new(block.bytes()));
BlockBufCursor {
rem: self.len(),
blocks: iter,
curr: block,
}
}
/// Consumes `n` buffered bytes, returning them as an immutable `Bytes`
/// value.
///
/// # Panics
///
/// Panics if `n` is greater than the number of buffered bytes.
pub fn shift(&mut self, mut n: usize) -> Bytes {
trace!("BlockBuf::shift; n={}", n);
let mut ret: Option<Bytes> = None;
while n > 0 {
if !self.have_buffered_data() {
panic!("shift len out of buffered range");
}
let (segment, pop) = {
let block = self.blocks.front().expect("unexpected state");
let segment_n = cmp::min(n, block.len());
n -= segment_n;
self.len -= segment_n;
(block.shift(segment_n), !MutBuf::has_remaining(block))
};
if pop {
let _ = self.blocks.pop_front();
}
ret = Some(match ret.take() {
Some(curr) => curr.concat(&segment),
None => segment,
});
}
ret.unwrap_or(Bytes::empty())
}
/// Drop the first `n` buffered bytes
///
/// # Panics
///
/// Panics if `n` is greater than the number of buffered bytes.
pub fn drop(&mut self, mut n: usize) {
while n > 0 {
if !self.have_buffered_data() {
panic!("shift len out of buffered range");
}
let pop = {
let block = self.blocks.front().expect("unexpected state");
let segment_n = cmp::min(n, block.len());
n -= segment_n;
self.len -= segment_n;
block.drop(segment_n);
!MutBuf::has_remaining(block)
};
if pop {
let _ = self.blocks.pop_front();
}
}
}
/// Moves all buffered bytes into a single block.
///
/// # Panics
///
/// Panics if the buffered bytes cannot fit in a single block.
pub fn compact(&mut self) {
trace!("BlockBuf::compact; attempting compaction");
if self.can_compact() {
trace!("BlockBuf::compact; data not aligned at start -- compacting");
let mut compacted = self.new_block.new_block()
.expect("unable to allocate block");
for block in self.blocks.drain(..) {
compacted.write_slice(block.bytes());
}
assert!(self.blocks.is_empty(), "blocks not removed");
self.blocks.push_back(compacted);
}
}
#[inline]
fn can_compact(&self) -> bool {
if self.blocks.len() > 1 {
return true;
}
self.blocks.front()
.map(|b| b.capacity() != self.new_block.block_size())
.unwrap_or(false)
}
/// Return byte slice if bytes are in sequential memory
#[inline]
pub fn bytes(&self) -> Option<&[u8]> {
match self.blocks.len() {
0 => Some(unsafe { slice::from_raw_parts(ptr::null(), 0) }),
1 => self.blocks.front().map(|b| b.bytes()),
_ => None,
}
}
#[inline]
fn block_size(&self) -> usize {
self.new_block.block_size()
}
#[inline]
fn allocate_block(&mut self) {
if let Some(block) = self.new_block.new_block() {
// Store the block
self.blocks.push_back(block);
}
}
#[inline]
fn have_buffered_data(&self) -> bool {
self.len() > 0
}
}
impl MutBuf for BlockBuf {
#[inline]
fn remaining(&self) -> usize {
// TODO: Ensure that the allocator has enough capacity to provide the
// remaining bytes
self.cap - self.len
}
#[inline]
fn has_remaining(&self) -> bool {
// TODO: Ensure that the allocator has enough capacity to provide the
// remaining bytes
self.cap != self.len
}
unsafe fn advance(&mut self, cnt: usize) {
trace!("BlockBuf::advance; cnt={:?}", cnt);
// `mut_bytes` only returns bytes from the last block, thus it should
// only be possible to advance the last block
if let Some(buf) = self.blocks.back_mut() {
self.len += cnt;
buf.advance(cnt);
}
}
unsafe fn mut_bytes(&mut self) -> &mut [u8] {
let mut need_alloc = true;
if let Some(buf) = self.blocks.back() {
// `unallocated_blocks` is checked here because if further blocks
// cannot be allocated, an empty slice should be returned.
if MutBuf::has_remaining(buf) {
need_alloc = false
}
}
if need_alloc {
if self.blocks.len() != self.blocks.capacity() {
self.allocate_block()
}
}
self.blocks.back_mut()
.map(|buf| buf.mut_bytes())
.unwrap_or(slice::from_raw_parts_mut(ptr::null_mut(), 0))
}
}
impl Default for BlockBuf {
fn default() -> BlockBuf {
BlockBuf::new(16, NewBlock::Heap(8_192))
}
}
impl<'a> Buf for BlockBufCursor<'a> {
fn remaining(&self) -> usize {
self.rem
}
fn bytes(&self) -> &[u8] {
self.curr.as_ref()
.map(|buf| Buf::bytes(buf))
.unwrap_or(unsafe { slice::from_raw_parts(ptr::null(), 0)})
}
fn advance(&mut self, mut cnt: usize) {
cnt = cmp::min(cnt, self.rem);
// Advance the internal cursor
self.rem -= cnt;
// Advance the leaf buffer
while cnt > 0 {
{
let curr = self.curr.as_mut()
.expect("expected a value");
if curr.remaining() > cnt {
curr.advance(cnt);
break;
}
cnt -= curr.remaining();
}
self.curr = self.blocks.next()
.map(|block| Cursor::new(block.bytes()));
}
}
}
impl NewBlock {
#[inline]
fn block_size(&self) -> usize {
match *self {
NewBlock::Heap(size) => size,
NewBlock::Pool(ref pool) => pool.buffer_len(),
}
}
#[inline]
fn new_block(&self) -> Option<AppendBuf> {
match *self {
NewBlock::Heap(size) => Some(AppendBuf::with_capacity(size as u32)),
NewBlock::Pool(ref pool) => pool.new_append_buf(),
}
}
}
src/buf/byte.rs
+14 -90
View File
@@ -1,4 +1,4 @@
use {alloc, Buf, Bytes, MutBuf, SeqByteStr, MAX_CAPACITY};
use {alloc, Buf, MutBuf, Bytes, MAX_CAPACITY};
use std::{cmp, fmt};
/*
@@ -98,30 +98,17 @@ impl ByteBuf {
MutByteBuf { buf: self }
}
pub fn read_slice(&mut self, dst: &mut [u8]) -> usize {
let len = cmp::min(dst.len(), self.remaining());
pub fn read_slice(&mut self, dst: &mut [u8]) {
assert!(self.remaining() >= dst.len());
let len = dst.len();
let cnt = len as u32;
let pos = self.pos as usize;
unsafe {
dst[0..len].copy_from_slice(&self.mem.bytes()[pos..pos+len]);
dst.copy_from_slice(&self.mem.bytes()[pos..pos+len]);
}
self.pos += cnt;
len
}
pub fn to_seq_byte_str(self) -> SeqByteStr {
unsafe {
let ByteBuf { mem, pos, lim, .. } = self;
SeqByteStr::from_mem_ref(
mem, pos, lim - pos)
}
}
#[inline]
pub fn to_bytes(self) -> Bytes {
Bytes::of(self.to_seq_byte_str())
}
/// Marks the current read location.
@@ -180,84 +167,21 @@ impl Buf for ByteBuf {
}
#[inline]
fn read_slice(&mut self, dst: &mut [u8]) -> usize {
fn read_slice(&mut self, dst: &mut [u8]) {
ByteBuf::read_slice(self, dst)
}
}
impl fmt::Debug for ByteBuf {
fn fmt(&self, fmt: &mut fmt::Formatter) -> fmt::Result {
self.bytes().fmt(fmt)
}
}
/*
*
* ===== ROByteBuf =====
*
*/
/// Same as `ByteBuf` but cannot be flipped to a `MutByteBuf`.
pub struct ROByteBuf {
buf: ByteBuf,
}
impl ROByteBuf {
pub unsafe fn from_mem_ref(mem: alloc::MemRef, cap: u32, pos: u32, lim: u32) -> ROByteBuf {
ROByteBuf {
buf: ByteBuf::from_mem_ref(mem, cap, pos, lim)
impl From<ByteBuf> for Bytes {
fn from(src: ByteBuf) -> Bytes {
unsafe {
let ByteBuf { mem, pos, lim, .. } = src;
Bytes::from_mem_ref(mem, pos, lim - pos)
}
}
pub fn to_seq_byte_str(self) -> SeqByteStr {
self.buf.to_seq_byte_str()
}
pub fn to_bytes(self) -> Bytes {
self.buf.to_bytes()
}
/// Marks the current read location.
///
/// Together with `reset`, this can be used to read from a section of the
/// buffer multiple times.
pub fn mark(&mut self) {
self.buf.mark = Some(self.buf.pos);
}
/// Resets the read position to the previously marked position.
///
/// Together with `mark`, this can be used to read from a section of the
/// buffer multiple times.
///
/// # Panics
///
/// This method will panic if no mark has been set.
pub fn reset(&mut self) {
self.buf.pos = self.buf.mark.take().expect("no mark set");
}
}
impl Buf for ROByteBuf {
fn remaining(&self) -> usize {
self.buf.remaining()
}
fn bytes<'a>(&'a self) -> &'a [u8] {
self.buf.bytes()
}
fn advance(&mut self, cnt: usize) {
self.buf.advance(cnt)
}
fn read_slice(&mut self, dst: &mut [u8]) -> usize {
self.buf.read_slice(dst)
}
}
impl fmt::Debug for ROByteBuf {
impl fmt::Debug for ByteBuf {
fn fmt(&self, fmt: &mut fmt::Formatter) -> fmt::Result {
self.bytes().fmt(fmt)
}
@@ -297,7 +221,7 @@ impl MutByteBuf {
let pos = self.buf.pos as usize;
unsafe {
self.buf.mem.bytes_mut()[pos..pos+cnt]
self.buf.mem.mut_bytes()[pos..pos+cnt]
.copy_from_slice(&src[0..cnt]);
}
@@ -323,7 +247,7 @@ impl MutBuf for MutByteBuf {
unsafe fn mut_bytes<'a>(&'a mut self) -> &'a mut [u8] {
let pos = self.buf.pos();
let lim = self.buf.lim();
&mut self.buf.mem.bytes_mut()[pos..lim]
&mut self.buf.mem.mut_bytes()[pos..lim]
}
}
src/buf/mod.rs
+76 -117
View File
@@ -1,16 +1,10 @@
mod append;
mod byte;
mod ring;
mod sink;
mod source;
mod take;
pub mod append;
pub mod block;
pub mod byte;
pub mod ring;
pub mod take;
pub use self::append::AppendBuf;
pub use self::byte::{ByteBuf, MutByteBuf, ROByteBuf};
pub use self::ring::RingBuf;
pub use self::take::Take;
use {ByteStr, RopeBuf};
use {Bytes};
use std::{cmp, fmt, io, ptr, usize};
/// A trait for values that provide sequential read access to bytes.
@@ -21,7 +15,7 @@ pub trait Buf {
/// Returns a slice starting at the current Buf position and of length
/// between 0 and `Buf::remaining()`.
fn bytes<'a>(&'a self) -> &'a [u8];
fn bytes(&self) -> &[u8];
/// Advance the internal cursor of the Buf
fn advance(&mut self, cnt: usize);
@@ -33,7 +27,9 @@ pub trait Buf {
fn copy_to<S: Sink>(&mut self, dst: S) -> usize
where Self: Sized {
dst.copy_from(self)
let rem = self.remaining();
dst.copy_from(self);
rem - self.remaining()
}
/// Read bytes from the `Buf` into the given slice and advance the cursor by
@@ -51,16 +47,17 @@ pub trait Buf {
/// assert_eq!(b"hello", &dst);
/// assert_eq!(6, buf.remaining());
/// ```
fn read_slice(&mut self, dst: &mut [u8]) -> usize {
fn read_slice(&mut self, dst: &mut [u8]) {
let mut off = 0;
let len = cmp::min(dst.len(), self.remaining());
while off < len {
assert!(self.remaining() >= dst.len());
while off < dst.len() {
let cnt;
unsafe {
let src = self.bytes();
cnt = cmp::min(src.len(), len - off);
cnt = cmp::min(src.len(), dst.len() - off);
ptr::copy_nonoverlapping(
src.as_ptr(), dst[off..].as_mut_ptr(), cnt);
@@ -70,24 +67,30 @@ pub trait Buf {
self.advance(cnt);
}
len
}
/// Read a single byte from the `Buf`
fn read_byte(&mut self) -> Option<u8> {
let mut dst = [0];
if self.read_slice(&mut dst) == 0 {
return None;
if self.has_remaining() {
let mut dst = [0];
self.read_slice(&mut dst);
Some(dst[0])
} else {
None
}
}
Some(dst[0])
fn peek_byte(&self) -> Option<u8> {
if self.has_remaining() {
Some(self.bytes()[0])
} else {
None
}
}
}
/// A trait for values that provide sequential write access to bytes.
pub trait MutBuf : Sized {
pub trait MutBuf {
/// Returns the number of bytes that can be written to the MutBuf
fn remaining(&self) -> usize;
@@ -108,7 +111,9 @@ pub trait MutBuf : Sized {
fn copy_from<S: Source>(&mut self, src: S) -> usize
where Self: Sized {
src.copy_to(self)
let rem = self.remaining();
src.copy_to(self);
rem - self.remaining()
}
/// Write bytes from the given slice into the `MutBuf` and advance the
@@ -130,16 +135,17 @@ pub trait MutBuf : Sized {
///
/// assert_eq!(b"hello\0", &dst);
/// ```
fn write_slice(&mut self, src: &[u8]) -> usize {
fn write_slice(&mut self, src: &[u8]) {
let mut off = 0;
let len = cmp::min(src.len(), self.remaining());
while off < len {
assert!(self.remaining() >= src.len(), "buffer overflow");
while off < src.len() {
let cnt;
unsafe {
let dst = self.mut_bytes();
cnt = cmp::min(dst.len(), len - off);
cnt = cmp::min(dst.len(), src.len() - off);
ptr::copy_nonoverlapping(
src[off..].as_ptr(),
@@ -152,8 +158,10 @@ pub trait MutBuf : Sized {
unsafe { self.advance(cnt); }
}
}
len
fn write_str(&mut self, src: &str) {
self.write_slice(src.as_bytes());
}
}
@@ -166,32 +174,41 @@ pub trait MutBuf : Sized {
/// A value that writes bytes from itself into a `MutBuf`.
pub trait Source {
fn copy_to<B: MutBuf>(self, buf: &mut B) -> usize;
fn copy_to<B: MutBuf>(self, buf: &mut B);
}
impl<'a> Source for &'a [u8] {
fn copy_to<B: MutBuf>(self, buf: &mut B) -> usize {
buf.write_slice(self)
fn copy_to<B: MutBuf>(self, buf: &mut B) {
buf.write_slice(self);
}
}
impl Source for u8 {
fn copy_to<B: MutBuf>(self, buf: &mut B) -> usize {
fn copy_to<B: MutBuf>(self, buf: &mut B) {
let src = [self];
buf.write_slice(&src)
buf.write_slice(&src);
}
}
impl<'a, T: ByteStr> Source for &'a T {
fn copy_to<B: MutBuf>(self, buf: &mut B) -> usize {
let mut src = ByteStr::buf(self);
let mut res = 0;
impl Source for Bytes {
fn copy_to<B: MutBuf>(self, buf: &mut B) {
Source::copy_to(&self, buf);
}
}
while src.has_remaining() && buf.has_remaining() {
impl<'a> Source for &'a Bytes {
fn copy_to<B: MutBuf>(self, buf: &mut B) {
Source::copy_to(self.buf(), buf);
}
}
impl<T: Buf> Source for T {
fn copy_to<B: MutBuf>(mut self, buf: &mut B) {
while self.has_remaining() && buf.has_remaining() {
let l;
unsafe {
let s = src.bytes();
let s = self.bytes();
let d = buf.mut_bytes();
l = cmp::min(s.len(), d.len());
@@ -201,28 +218,24 @@ impl<'a, T: ByteStr> Source for &'a T {
l);
}
src.advance(l);
self.advance(l);
unsafe { buf.advance(l); }
res += l;
}
res
}
}
pub trait Sink {
fn copy_from<B: Buf>(self, buf: &mut B) -> usize;
fn copy_from<B: Buf>(self, buf: &mut B);
}
impl<'a> Sink for &'a mut [u8] {
fn copy_from<B: Buf>(self, buf: &mut B) -> usize {
buf.read_slice(self)
fn copy_from<B: Buf>(self, buf: &mut B) {
buf.read_slice(self);
}
}
impl<'a> Sink for &'a mut Vec<u8> {
fn copy_from<B: Buf>(self, buf: &mut B) -> usize {
fn copy_from<B: Buf>(self, buf: &mut B) {
use std::slice;
self.clear();
@@ -238,15 +251,11 @@ impl<'a> Sink for &'a mut Vec<u8> {
unsafe {
{
let dst = &mut self[..];
let cnt = buf.read_slice(slice::from_raw_parts_mut(dst.as_mut_ptr(), rem));
debug_assert!(cnt == rem);
buf.read_slice(slice::from_raw_parts_mut(dst.as_mut_ptr(), rem));
}
self.set_len(rem);
}
rem
}
}
@@ -297,30 +306,6 @@ impl<T: io::Write> WriteExt for T {
*
*/
impl Buf for Box<Buf+Send+'static> {
fn remaining(&self) -> usize {
(**self).remaining()
}
fn bytes(&self) -> &[u8] {
(**self).bytes()
}
fn advance(&mut self, cnt: usize) {
(**self).advance(cnt);
}
fn read_slice(&mut self, dst: &mut [u8]) -> usize {
(**self).read_slice(dst)
}
}
impl fmt::Debug for Box<Buf+Send+'static> {
fn fmt(&self, fmt: &mut fmt::Formatter) -> fmt::Result {
write!(fmt, "Box<Buf> {{ remaining: {} }}", self.remaining())
}
}
impl<T: AsRef<[u8]>> Buf for io::Cursor<T> {
fn remaining(&self) -> usize {
self.get_ref().as_ref().len() - self.position() as usize
@@ -396,45 +381,19 @@ impl MutBuf for Vec<u8> {
/*
*
* ===== Read impls =====
* ===== fmt impls =====
*
*/
macro_rules! impl_read {
($ty:ty) => {
impl io::Read for $ty {
fn read(&mut self, buf: &mut [u8]) -> io::Result<usize> {
if !self.has_remaining() {
return Ok(0);
}
pub struct Fmt<'a, B: 'a>(pub &'a mut B);
Ok(self.read_slice(buf))
}
}
impl<'a, B: MutBuf> fmt::Write for Fmt<'a, B> {
fn write_str(&mut self, s: &str) -> fmt::Result {
self.0.write_str(s);
Ok(())
}
fn write_fmt(&mut self, args: fmt::Arguments) -> fmt::Result {
fmt::write(self, args)
}
}
impl_read!(ByteBuf);
impl_read!(ROByteBuf);
impl_read!(RopeBuf);
impl_read!(Box<Buf+Send+'static>);
macro_rules! impl_write {
($ty:ty) => {
impl io::Write for $ty {
fn write(&mut self, buf: &[u8]) -> io::Result<usize> {
if !self.has_remaining() {
return Ok(0);
}
Ok(self.write_slice(buf))
}
fn flush(&mut self) -> io::Result<()> {
Ok(())
}
}
}
}
impl_write!(MutByteBuf);
src/buf/ring.rs
+2 -3
View File
@@ -144,7 +144,6 @@ impl fmt::Debug for RingBuf {
}
impl Buf for RingBuf {
fn remaining(&self) -> usize {
self.read_remaining()
}
@@ -176,7 +175,7 @@ impl MutBuf for RingBuf {
unsafe fn mut_bytes(&mut self) -> &mut [u8] {
if self.cap == 0 {
return self.ptr.bytes_mut();
return self.ptr.mut_bytes();
}
let mut from;
let mut to;
@@ -190,7 +189,7 @@ impl MutBuf for RingBuf {
to = self.cap;
}
&mut self.ptr.bytes_mut()[from..to]
&mut self.ptr.mut_bytes()[from..to]
}
}
src/buf/sink.rs
View File
src/buf/source.rs
View File
src/buf/take.rs
+1 -11
View File
@@ -1,5 +1,5 @@
use buf::{Buf, MutBuf};
use std::{cmp, io};
use std::{cmp};
#[derive(Debug)]
pub struct Take<T> {
@@ -52,16 +52,6 @@ impl<T: Buf> Buf for Take<T> {
}
}
impl<T: Buf> io::Read for Take<T> {
fn read(&mut self, buf: &mut [u8]) -> io::Result<usize> {
if !self.has_remaining() {
return Ok(0);
}
Ok(self.read_slice(buf))
}
}
impl<T: MutBuf> MutBuf for Take<T> {
fn remaining(&self) -> usize {
cmp::min(self.inner.remaining(), self.limit)
src/bytes/mod.rs
+240
View File
@@ -0,0 +1,240 @@
mod rope;
mod seq;
mod small;
use alloc;
use buf::Buf;
use self::seq::Seq;
use self::small::Small;
use self::rope::{Rope, RopeBuf};
use std::{cmp, fmt, ops};
use std::io::Cursor;
#[derive(Clone)]
pub struct Bytes {
kind: Kind,
}
#[derive(Clone)]
enum Kind {
Seq(Seq),
Small(Small),
Rope(Rope),
}
pub struct BytesBuf<'a> {
kind: BufKind<'a>,
}
enum BufKind<'a> {
Cursor(Cursor<&'a [u8]>),
Rope(RopeBuf<'a>),
}
impl Bytes {
/// Return an empty `Bytes`
pub fn empty() -> Bytes {
Bytes { kind: Kind::Small(Small::empty()) }
}
/// Creates a new `Bytes` from a `MemRef`, an offset, and a length.
///
/// This function is unsafe as there are no guarantees that the given
/// arguments are valid.
pub unsafe fn from_mem_ref(mem: alloc::MemRef, pos: u32, len: u32) -> Bytes {
Small::from_slice(&mem.bytes()[pos as usize .. pos as usize + len as usize])
.map(|b| Bytes { kind: Kind::Small(b) })
.unwrap_or_else(|| {
let seq = Seq::from_mem_ref(mem, pos, len);
Bytes { kind: Kind::Seq(seq) }
})
}
pub fn buf(&self) -> BytesBuf {
let kind = match self.kind {
Kind::Seq(ref v) => BufKind::Cursor(v.buf()),
Kind::Small(ref v) => BufKind::Cursor(v.buf()),
Kind::Rope(ref v) => BufKind::Rope(v.buf()),
};
BytesBuf { kind: kind }
}
pub fn is_empty(&self) -> bool {
self.len() == 0
}
pub fn len(&self) -> usize {
match self.kind {
Kind::Seq(ref v) => v.len(),
Kind::Small(ref v) => v.len(),
Kind::Rope(ref v) => v.len(),
}
}
pub fn concat(&self, other: &Bytes) -> Bytes {
Rope::concat(self.clone(), other.clone())
}
/// Returns a new ByteStr value containing the byte range between `begin`
/// (inclusive) and `end` (exclusive)
pub fn slice(&self, begin: usize, end: usize) -> Bytes {
match self.kind {
Kind::Seq(ref v) => v.slice(begin, end),
Kind::Small(ref v) => v.slice(begin, end),
Kind::Rope(ref v) => v.slice(begin, end),
}
}
/// Returns a new ByteStr value containing the byte range starting from
/// `begin` (inclusive) to the end of the byte str.
///
/// Equivalent to `bytes.slice(begin, bytes.len())`
pub fn slice_from(&self, begin: usize) -> Bytes {
self.slice(begin, self.len())
}
/// Returns a new ByteStr value containing the byte range from the start up
/// to `end` (exclusive).
///
/// Equivalent to `bytes.slice(0, end)`
pub fn slice_to(&self, end: usize) -> Bytes {
self.slice(0, end)
}
/// Returns the Rope depth
fn depth(&self) -> u16 {
match self.kind {
Kind::Rope(ref r) => r.depth(),
_ => 0,
}
}
fn into_rope(self) -> Result<Rope, Bytes> {
match self.kind {
Kind::Rope(r) => Ok(r),
_ => Err(self),
}
}
}
impl ops::Index<usize> for Bytes {
type Output = u8;
fn index(&self, index: usize) -> &u8 {
match self.kind {
Kind::Seq(ref v) => v.index(index),
Kind::Small(ref v) => v.index(index),
Kind::Rope(ref v) => v.index(index),
}
}
}
impl<T: AsRef<[u8]>> From<T> for Bytes {
fn from(src: T) -> Bytes {
Small::from_slice(src.as_ref())
.map(|b| Bytes { kind: Kind::Small(b) })
.unwrap_or_else(|| Seq::from_slice(src.as_ref()))
}
}
impl cmp::PartialEq<Bytes> for Bytes {
fn eq(&self, other: &Bytes) -> bool {
if self.len() != other.len() {
return false;
}
let mut buf1 = self.buf();
let mut buf2 = self.buf();
while buf1.has_remaining() {
let len;
{
let b1 = buf1.bytes();
let b2 = buf2.bytes();
len = cmp::min(b1.len(), b2.len());
if b1[..len] != b2[..len] {
return false;
}
}
buf1.advance(len);
buf2.advance(len);
}
true
}
fn ne(&self, other: &Bytes) -> bool {
return !self.eq(other)
}
}
impl<'a> Buf for BytesBuf<'a> {
fn remaining(&self) -> usize {
match self.kind {
BufKind::Cursor(ref v) => v.remaining(),
BufKind::Rope(ref v) => v.remaining(),
}
}
fn bytes(&self) -> &[u8] {
match self.kind {
BufKind::Cursor(ref v) => v.bytes(),
BufKind::Rope(ref v) => v.bytes(),
}
}
fn advance(&mut self, cnt: usize) {
match self.kind {
BufKind::Cursor(ref mut v) => v.advance(cnt),
BufKind::Rope(ref mut v) => v.advance(cnt),
}
}
}
/*
*
* ===== Internal utilities =====
*
*/
impl fmt::Debug for Bytes {
fn fmt(&self, fmt: &mut fmt::Formatter) -> fmt::Result {
let mut buf = self.buf();
try!(write!(fmt, "Bytes[len={}; ", self.len()));
let mut rem = 128;
while let Some(byte) = buf.read_byte() {
if rem > 0 {
if is_ascii(byte) {
try!(write!(fmt, "{}", byte as char));
} else {
try!(write!(fmt, "\\x{:02X}", byte));
}
rem -= 1;
} else {
try!(write!(fmt, " ... "));
break;
}
}
try!(write!(fmt, "]"));
Ok(())
}
}
fn is_ascii(byte: u8) -> bool {
match byte {
10 | 13 | 32...126 => true,
_ => false,
}
}
src/bytes/rope.rs
+642
View File
@@ -0,0 +1,642 @@
use {Bytes, ByteBuf};
use buf::{Buf, MutBuf, Source};
use bytes::seq::Seq;
use bytes::small::{Small};
use std::{cmp, ops};
use std::io::Cursor;
use std::sync::Arc;
// The implementation is mostly a port of the implementation found in the Java
// protobuf lib.
const CONCAT_BY_COPY_LEN: usize = 128;
const MAX_DEPTH: usize = 47;
// Used to decide when to rebalance the tree.
static MIN_LENGTH_BY_DEPTH: [usize; MAX_DEPTH] = [
1, 2, 3, 5, 8,
13, 21, 34, 55, 89,
144, 233, 377, 610, 987,
1_597, 2_584, 4_181, 6_765, 10_946,
17_711, 28_657, 46_368, 75_025, 121_393,
196_418, 317_811, 514_229, 832_040, 1_346_269,
2_178_309, 3_524_578, 5_702_887, 9_227_465, 14_930_352,
24_157_817, 39_088_169, 63_245_986, 102_334_155, 165_580_141,
267_914_296, 433_494_437, 701_408_733, 1_134_903_170, 1_836_311_903,
2_971_215_073, 4_294_967_295];
/// An immutable sequence of bytes formed by concatenation of other `ByteStr`
/// values, without copying the data in the pieces. The concatenation is
/// represented as a tree whose leaf nodes are each a `Bytes` value.
///
/// Most of the operation here is inspired by the now-famous paper [Ropes: an
/// Alternative to Strings. hans-j. boehm, russ atkinson and michael
/// plass](http://www.cs.rit.edu/usr/local/pub/jeh/courses/QUARTERS/FP/Labs/CedarRope/rope-paper.pdf).
///
/// Fundamentally the Rope algorithm represents the collection of pieces as a
/// binary tree. BAP95 uses a Fibonacci bound relating depth to a minimum
/// sequence length, sequences that are too short relative to their depth cause
/// a tree rebalance. More precisely, a tree of depth d is "balanced" in the
/// terminology of BAP95 if its length is at least F(d+2), where F(n) is the
/// n-the Fibonacci number. Thus for depths 0, 1, 2, 3, 4, 5,... we have
/// minimum lengths 1, 2, 3, 5, 8, 13,...
#[derive(Clone)]
pub struct Rope {
left: Node,
right: Node,
depth: u16,
len: usize,
}
pub struct RopeBuf<'a> {
// Number of bytes left to iterate
rem: usize,
// Iterates all the leaf nodes in order
nodes: NodeIter<'a>,
// Current leaf node buffer
leaf_buf: Option<Cursor<&'a [u8]>>,
}
#[derive(Clone)]
enum Node {
Empty,
Seq(Seq),
Small(Small),
Rope(Arc<Rope>),
}
// TODO: store stack inline if possible
struct NodeIter<'a> {
stack: Vec<&'a Rope>,
next: Option<&'a Node>,
}
/// Balance operation state
struct Balance {
stack: Vec<Partial>,
}
/// Temporarily detached branch
enum Partial {
Bytes(Bytes),
Node(Node),
}
impl Rope {
fn new<N1: Into<Node>, N2: Into<Node>>(left: N1, right: N2) -> Rope {
let left = left.into();
let right = right.into();
debug_assert!(!left.is_empty() || right.is_empty());
// If left is 0 then right must be zero
let len = left.len() + right.len();
let depth = cmp::max(left.depth(), right.depth()) + 1;
Rope {
left: left,
right: right,
depth: depth,
len: len,
}
}
pub fn buf(&self) -> RopeBuf {
let mut nodes = NodeIter::new(self);
// Get the next leaf node buffer
let leaf_buf = nodes.next()
.map(|node| node.leaf_buf());
RopeBuf {
rem: self.len(),
nodes: nodes,
leaf_buf: leaf_buf,
}
}
/// Concat two `Bytes` together.
pub fn concat(left: Bytes, right: Bytes) -> Bytes {
if right.is_empty() {
return left;
}
if left.is_empty() {
return right;
}
let len = left.len() + right.len();
if len < CONCAT_BY_COPY_LEN {
return concat_bytes(&left, &right, len);
}
let left = match left.into_rope() {
Ok(left) => {
let len = left.right.len() + right.len();
if len < CONCAT_BY_COPY_LEN {
// Optimization from BAP95: As an optimization of the case
// where the ByteString is constructed by repeated concatenate,
// recognize the case where a short string is concatenated to a
// left-hand node whose right-hand branch is short. In the
// paper this applies to leaves, but we just look at the length
// here. This has the advantage of shedding references to
// unneeded data when substrings have been taken.
//
// When we recognize this case, we do a copy of the data and
// create a new parent node so that the depth of the result is
// the same as the given left tree.
let new_right = concat_bytes(&left.right, &right, len);
return Rope::new(left.left, new_right).into_bytes();
}
if left.left.depth() > left.right.depth() && left.depth > right.depth() {
// Typically for concatenate-built strings the left-side is
// deeper than the right. This is our final attempt to
// concatenate without increasing the tree depth. We'll redo
// the the node on the RHS. This is yet another optimization
// for building the string by repeatedly concatenating on the
// right.
let new_right = Rope::new(left.right, right);
return Rope::new(left.left, new_right).into_bytes();
}
left.into_bytes()
}
Err(left) => left,
};
// Fine, we'll add a node and increase the tree depth -- unless we
// rebalance ;^)
let depth = cmp::max(left.depth(), right.depth()) + 1;
if len >= MIN_LENGTH_BY_DEPTH[depth as usize] {
// No need to rebalance
return Rope::new(left, right).into_bytes();
}
Balance::new().balance(left, right).into()
}
pub fn depth(&self) -> u16 {
self.depth
}
pub fn len(&self) -> usize {
self.len as usize
}
pub fn is_empty(&self) -> bool {
self.len() == 0
}
pub fn slice(&self, begin: usize, end: usize) -> Bytes {
// Assert args
assert!(begin <= end && end <= self.len(), "invalid range");
let len = end - begin;
// Empty slice
if len == 0 {
return Bytes::empty();
}
// Full rope
if len == self.len() {
return self.clone().into_bytes();
}
// == Proper substring ==
let left_len = self.left.len();
if end <= left_len {
// Slice on the left
return self.left.slice(begin, end);
}
if begin >= left_len {
// Slice on the right
return self.right.slice(begin - left_len, end - left_len);
}
// Split slice
let left_slice = self.left.slice(begin, self.left.len());
let right_slice = self.right.slice(0, end - left_len);
Rope::new(left_slice, right_slice).into_bytes()
}
fn into_bytes(self) -> Bytes {
use super::Kind;
Bytes { kind: Kind::Rope(self) }
}
}
impl Node {
fn len(&self) -> usize {
match *self {
Node::Seq(ref b) => b.len(),
Node::Small(ref b) => b.len(),
Node::Rope(ref b) => b.len,
Node::Empty => 0,
}
}
fn is_empty(&self) -> bool {
self.len() == 0
}
fn depth(&self) -> u16 {
match *self {
Node::Rope(ref r) => r.depth,
_ => 0,
}
}
fn slice(&self, begin: usize, end: usize) -> Bytes {
match *self {
Node::Seq(ref v) => v.slice(begin, end),
Node::Small(ref v) => v.slice(begin, end),
Node::Rope(ref v) => v.slice(begin, end),
Node::Empty => unreachable!(),
}
}
fn leaf_buf(&self) -> Cursor<&[u8]> {
match *self {
Node::Seq(ref v) => v.buf(),
Node::Small(ref v) => v.buf(),
_ => unreachable!(),
}
}
fn as_rope(&self) -> Option<&Rope> {
match *self {
Node::Rope(ref v) => Some(&**v),
_ => None,
}
}
}
impl<'a> Source for &'a Node {
fn copy_to<B: MutBuf>(self, buf: &mut B) {
match *self {
Node::Seq(ref b) => b.as_slice().copy_to(buf),
Node::Small(ref b) => b.as_ref().copy_to(buf),
Node::Rope(ref b) => b.buf().copy_to(buf),
Node::Empty => unreachable!(),
}
}
}
impl From<Bytes> for Node {
fn from(src: Bytes) -> Node {
use super::Kind;
match src.kind {
Kind::Seq(b) => Node::Seq(b),
Kind::Small(b) => Node::Small(b),
Kind::Rope(b) => Node::Rope(Arc::new(b)),
}
}
}
impl From<Rope> for Node {
fn from(src: Rope) -> Node {
Node::Rope(Arc::new(src))
}
}
impl ops::Index<usize> for Rope {
type Output = u8;
fn index(&self, index: usize) -> &u8 {
assert!(index < self.len());
let left_len = self.left.len();
if index < left_len {
self.left.index(index)
} else {
self.right.index(index - left_len)
}
}
}
impl ops::Index<usize> for Node {
type Output = u8;
fn index(&self, index: usize) -> &u8 {
match *self {
Node::Seq(ref v) => v.index(index),
Node::Small(ref v) => v.index(index),
Node::Rope(ref v) => v.index(index),
Node::Empty => unreachable!(),
}
}
}
/*
*
* ===== Helper Fns =====
*
*/
fn concat_bytes<S1, S2>(left: S1, right: S2, len: usize) -> Bytes
where S1: Source, S2: Source,
{
let mut buf = ByteBuf::mut_with_capacity(len);
buf.copy_from(left);
buf.copy_from(right);
return buf.flip().into();
}
fn depth_for_len(len: usize) -> u16 {
match MIN_LENGTH_BY_DEPTH.binary_search(&len) {
Ok(idx) => idx as u16,
Err(idx) => {
// It wasn't an exact match, so convert to the index of the
// containing fragment, which is one less even than the insertion
// point.
idx as u16 - 1
}
}
}
impl<'a> NodeIter<'a> {
fn new(root: &'a Rope) -> NodeIter<'a> {
let mut iter = NodeIter {
// TODO: Consider allocating with capacity for depth
stack: vec![],
next: None,
};
iter.next = iter.get_leaf_by_left(root);
iter
}
fn get_leaf_by_left(&mut self, mut root: &'a Rope) -> Option<&'a Node> {
loop {
self.stack.push(root);
let left = &root.left;
if left.is_empty() {
return None;
}
if let Some(rope) = left.as_rope() {
root = rope;
continue;
}
return Some(left);
}
}
fn next_non_empty_leaf(&mut self) -> Option<&'a Node>{
loop {
if let Some(rope) = self.stack.pop() {
if let Some(rope) = rope.right.as_rope() {
let res = self.get_leaf_by_left(&rope);
if res.is_none() {
continue;
}
return res;
}
if rope.right.is_empty() {
continue;
}
return Some(&rope.right);
}
return None;
}
}
}
impl<'a> Iterator for NodeIter<'a> {
type Item = &'a Node;
fn next(&mut self) -> Option<&'a Node> {
let ret = self.next.take();
if ret.is_some() {
self.next = self.next_non_empty_leaf();
}
ret
}
}
impl<'a> Buf for RopeBuf<'a> {
fn remaining(&self) -> usize {
self.rem
}
fn bytes(&self) -> &[u8] {
self.leaf_buf.as_ref()
.map(|b| b.bytes())
.unwrap_or(&[])
}
fn advance(&mut self, mut cnt: usize) {
cnt = cmp::min(cnt, self.rem);
// Advance the internal cursor
self.rem -= cnt;
// Advance the leaf buffer
while cnt > 0 {
{
let curr = self.leaf_buf.as_mut()
.expect("expected a value");
if curr.remaining() > cnt {
curr.advance(cnt);
break;
}
cnt -= curr.remaining();
}
self.leaf_buf = self.nodes.next()
.map(|node| node.leaf_buf());
}
}
}
/*
*
* ===== Balance =====
*
*/
impl Balance {
fn new() -> Balance {
Balance { stack: vec![] }
}
fn balance(&mut self, left: Bytes, right: Bytes) -> Bytes {
self.do_balance(Partial::Bytes(left));
self.do_balance(Partial::Bytes(right));
let mut partial = self.stack.pop()
.expect("expected a value");
while !partial.is_empty() {
let new_left = self.stack.pop()
.expect("expected a value");
partial = Partial::Bytes(Rope::new(new_left, partial).into_bytes());
}
partial.unwrap_bytes()
}
fn do_balance(&mut self, root: Partial) {
// BAP95: Insert balanced subtrees whole. This means the result might not
// be balanced, leading to repeated rebalancings on concatenate. However,
// these rebalancings are shallow due to ignoring balanced subtrees, and
// relatively few calls to insert() result.
if root.is_balanced() {
self.insert(root);
} else {
let rope = root.unwrap_rope();
self.do_balance(Partial::Node(rope.left));
self.do_balance(Partial::Node(rope.right));
}
}
// Push a string on the balance stack (BAP95). BAP95 uses an array and
// calls the elements in the array 'bins'. We instead use a stack, so the
// 'bins' of lengths are represented by differences between the elements of
// minLengthByDepth.
//
// If the length bin for our string, and all shorter length bins, are
// empty, we just push it on the stack. Otherwise, we need to start
// concatenating, putting the given string in the "middle" and continuing
// until we land in an empty length bin that matches the length of our
// concatenation.
fn insert(&mut self, bytes: Partial) {
let depth_bin = depth_for_len(bytes.len());
let bin_end = MIN_LENGTH_BY_DEPTH[depth_bin as usize + 1];
// BAP95: Concatenate all trees occupying bins representing the length
// of our new piece or of shorter pieces, to the extent that is
// possible. The goal is to clear the bin which our piece belongs in,
// but that may not be entirely possible if there aren't enough longer
// bins occupied.
if let Some(len) = self.peek().map(|r| r.len()) {
if len >= bin_end {
self.stack.push(bytes);
return;
}
}
let bin_start = MIN_LENGTH_BY_DEPTH[depth_bin as usize];
// Concatenate the subtrees of shorter length
let mut new_tree = self.stack.pop()
.expect("expected a value");
while let Some(len) = self.peek().map(|r| r.len()) {
// If the head is big enough, break the loop
if len >= bin_start { break; }
let left = self.stack.pop()
.expect("expected a value");
new_tree = Partial::Bytes(Rope::new(left, new_tree).into_bytes());
}
// Concatenate the given string
new_tree = Partial::Bytes(Rope::new(new_tree, bytes).into_bytes());
// Continue concatenating until we land in an empty bin
while let Some(len) = self.peek().map(|r| r.len()) {
let depth_bin = depth_for_len(new_tree.len());
let bin_end = MIN_LENGTH_BY_DEPTH[depth_bin as usize + 1];
if len < bin_end {
let left = self.stack.pop()
.expect("expected a value");
new_tree = Partial::Bytes(Rope::new(left, new_tree).into_bytes());
} else {
break;
}
}
self.stack.push(new_tree);
}
fn peek(&self) -> Option<&Partial> {
self.stack.last()
}
}
impl Partial {
fn is_empty(&self) -> bool {
self.len() == 0
}
fn len(&self) -> usize {
match *self {
Partial::Bytes(ref v) => v.len(),
Partial::Node(ref v) => v.len(),
}
}
fn depth(&self) -> u16 {
match *self {
Partial::Bytes(ref v) => v.depth(),
Partial::Node(ref v) => v.depth(),
}
}
fn is_balanced(&self) -> bool {
self.len() >= MIN_LENGTH_BY_DEPTH[self.depth() as usize]
}
fn unwrap_bytes(self) -> Bytes {
match self {
Partial::Bytes(v) => v,
_ => panic!("unexpected state calling `Partial::unwrap_bytes()`. Expected `Bytes`, got `Node`"),
}
}
fn unwrap_rope(self) -> Rope {
match self {
Partial::Bytes(v) => v.into_rope().ok().expect("unexpected state calling `Partial::unwrap_rope()`"),
Partial::Node(Node::Rope(v)) => {
match Arc::try_unwrap(v) {
Ok(v) => v,
Err(v) => (*v).clone(),
}
}
_ => panic!("unexpected state calling `Partial::unwrap_rope()`"),
}
}
}
impl From<Partial> for Node {
fn from(src: Partial) -> Node {
match src {
Partial::Node(v) => v,
Partial::Bytes(v) => Node::from(v),
}
}
}
src/bytes/seq.rs
+79
View File
@@ -0,0 +1,79 @@
//! Immutable set of bytes sequential in memory.
use {alloc, ByteBuf, MutBuf};
use bytes::{Bytes};
use std::ops;
use std::io::Cursor;
pub struct Seq {
mem: alloc::MemRef,
pos: u32,
len: u32,
}
impl Seq {
pub fn from_slice(bytes: &[u8]) -> Bytes {
let mut buf = ByteBuf::mut_with_capacity(bytes.len());
buf.copy_from(bytes);
buf.flip().into()
}
/// Creates a new `SeqByteStr` from a `MemRef`, an offset, and a length.
///
/// This function is unsafe as there are no guarantees that the given
/// arguments are valid.
pub unsafe fn from_mem_ref(mem: alloc::MemRef, pos: u32, len: u32) -> Seq {
Seq {
mem: mem,
pos: pos,
len: len,
}
}
pub fn len(&self) -> usize {
self.len as usize
}
pub fn slice(&self, begin: usize, end: usize) -> Bytes {
use super::Kind;
assert!(begin <= end && end <= self.len(), "invalid range");
let seq = unsafe {
Seq::from_mem_ref(
self.mem.clone(),
self.pos + begin as u32,
(end - begin) as u32)
};
Bytes { kind: Kind::Seq(seq) }
}
pub fn buf(&self) -> Cursor<&[u8]> {
Cursor::new(self.as_slice())
}
pub fn as_slice(&self) -> &[u8] {
unsafe { &self.mem.bytes()[self.pos as usize..self.pos as usize + self.len as usize] }
}
}
impl ops::Index<usize> for Seq {
type Output = u8;
fn index(&self, index: usize) -> &u8 {
assert!(index < self.len());
unsafe { self.mem.bytes().index(index + self.pos as usize) }
}
}
impl Clone for Seq {
fn clone(&self) -> Seq {
Seq {
mem: self.mem.clone(),
pos: self.pos,
len: self.len,
}
}
}
src/bytes/small.rs
+81
View File
@@ -0,0 +1,81 @@
use bytes::{Bytes};
use std::ops;
use std::io::Cursor;
/*
*
* ===== Small immutable set of bytes =====
*
*/
#[cfg(target_pointer_width = "64")]
const MAX_LEN: usize = 7;
#[cfg(target_pointer_width = "32")]
const MAX_LEN: usize = 3;
#[derive(Clone, Copy)]
pub struct Small {
len: u8,
bytes: [u8; MAX_LEN],
}
impl Small {
pub fn empty() -> Small {
use std::mem;
Small {
len: 0,
bytes: unsafe { mem::zeroed() }
}
}
pub fn from_slice(bytes: &[u8]) -> Option<Small> {
use std::{mem, ptr};
if bytes.len() > MAX_LEN {
return None;
}
let mut ret = Small {
len: bytes.len() as u8,
bytes: unsafe { mem::zeroed() },
};
// Copy the memory
unsafe {
ptr::copy_nonoverlapping(
bytes.as_ptr(),
ret.bytes.as_mut_ptr(),
bytes.len());
}
Some(ret)
}
pub fn buf(&self) -> Cursor<&[u8]> {
Cursor::new(self.as_ref())
}
pub fn slice(&self, begin: usize, end: usize) -> Bytes {
Bytes::from(&self.as_ref()[begin..end])
}
pub fn len(&self) -> usize {
self.len as usize
}}
impl AsRef<[u8]> for Small {
fn as_ref(&self) -> &[u8] {
&self.bytes[..self.len as usize]
}
}
impl ops::Index<usize> for Small {
type Output = u8;
fn index(&self, index: usize) -> &u8 {
assert!(index < self.len());
&self.bytes[index]
}
}
src/lib.rs
+14 -24
View File
@@ -3,31 +3,21 @@
extern crate stable_heap;
pub mod alloc;
pub mod buf;
pub mod str;
#[macro_use]
extern crate log;
pub use buf::{
Buf,
MutBuf,
ByteBuf,
MutByteBuf,
RingBuf,
ROByteBuf,
Take,
ReadExt,
WriteExt,
};
pub use str::{
ByteStr,
Bytes,
Rope,
RopeBuf,
SeqByteStr,
SmallByteStr,
SmallByteStrBuf,
ToBytes,
};
mod buf;
mod bytes;
pub mod alloc;
pub use buf::{Buf, MutBuf, Source, Sink, ReadExt, WriteExt, Fmt};
pub use buf::append::AppendBuf;
pub use buf::block::{BlockBuf, NewBlock, BlockBufCursor};
pub use buf::byte::{ByteBuf, MutByteBuf};
pub use buf::ring::RingBuf;
pub use buf::take::Take;
pub use bytes::Bytes;
use std::u32;
src/str/bytes.rs
-280
View File
@@ -1,280 +0,0 @@
use {ByteBuf, SmallByteStr};
use buf::{Buf};
use str::{ByteStr, ToBytes};
use std::{fmt, mem, ops, ptr};
use std::any::{TypeId};
const INLINE: usize = 1;
/// A specialized `ByteStr` box.
pub struct Bytes {
vtable: usize,
data: *mut (),
}
impl Bytes {
pub fn from_slice(bytes: &[u8]) -> Bytes {
SmallByteStr::from_slice(bytes)
.map(|small| Bytes::of(small))
.unwrap_or_else(|| ByteBuf::from_slice(bytes).to_bytes())
}
pub fn of<B: ByteStr>(bytes: B) -> Bytes {
unsafe {
if inline::<B>() {
let vtable;
let data;
{
let obj: &ByteStrPriv = &bytes;
let obj: TraitObject = mem::transmute(obj);
let ptr: *const *mut () = mem::transmute(obj.data);
data = *ptr;
vtable = obj.vtable;
}
// Prevent drop from being called
mem::forget(bytes);
Bytes {
vtable: vtable as usize | INLINE,
data: data,
}
} else {
let obj: Box<ByteStrPriv> = Box::new(bytes);
let obj: TraitObject = mem::transmute(obj);
Bytes {
vtable: obj.vtable as usize,
data: obj.data,
}
}
}
}
pub fn empty() -> Bytes {
Bytes::of(SmallByteStr::zero())
}
/// If the underlying `ByteStr` is of type `B`, returns a reference to it
/// otherwise None.
pub fn downcast_ref<'a, B: ByteStr>(&'a self) -> Option<&'a B> {
if TypeId::of::<B>() == self.obj().get_type_id() {
unsafe {
if inline::<B>() {
return Some(mem::transmute(&self.data));
} else {
return Some(mem::transmute(self.data));
}
}
}
None
}
/// If the underlying `ByteStr` is of type `B`, returns the unwraped value,
/// otherwise, returns the original `Bytes` as `Err`.
pub fn try_unwrap<B: ByteStr>(self) -> Result<B, Bytes> {
if TypeId::of::<B>() == self.obj().get_type_id() {
unsafe {
// Underlying ByteStr value is of the correct type. Unwrap it
let ret;
if inline::<B>() {
// The value is inline, read directly from the pointer
ret = ptr::read(mem::transmute(&self.data));
} else {
ret = ptr::read(mem::transmute(self.data));
}
mem::forget(self);
Ok(ret)
}
} else {
Err(self)
}
}
fn obj(&self) -> &ByteStrPriv {
unsafe {
mem::transmute(self.to_trait_object())
}
}
fn obj_mut(&mut self) -> &mut ByteStrPriv {
unsafe {
mem::transmute(self.to_trait_object())
}
}
unsafe fn to_trait_object(&self) -> TraitObject {
if self.is_inline() {
TraitObject {
data: mem::transmute(&self.data),
vtable: mem::transmute(self.vtable - 1),
}
} else {
TraitObject {
data: self.data,
vtable: mem::transmute(self.vtable),
}
}
}
fn is_inline(&self) -> bool {
(self.vtable & INLINE) == INLINE
}
}
fn inline<B: ByteStr>() -> bool {
mem::size_of::<B>() <= 2 * mem::size_of::<usize>()
}
impl ByteStr for Bytes {
type Buf = Box<Buf+Send+'static>;
fn buf(&self) -> Box<Buf+Send+'static> {
self.obj().buf()
}
fn concat<B: ByteStr>(&self, other: &B) -> Bytes {
self.obj().concat(&Bytes::of(other.clone()))
}
fn len(&self) -> usize {
self.obj().len()
}
fn slice(&self, begin: usize, end: usize) -> Bytes {
self.obj().slice(begin, end)
}
fn split_at(&self, mid: usize) -> (Bytes, Bytes) {
self.obj().split_at(mid)
}
}
impl ToBytes for Bytes {
fn to_bytes(self) -> Bytes {
self
}
}
impl ops::Index<usize> for Bytes {
type Output = u8;
fn index(&self, index: usize) -> &u8 {
self.obj().index(index)
}
}
impl fmt::Debug for Bytes {
fn fmt(&self, fmt: &mut fmt::Formatter) -> fmt::Result {
super::debug(self, "Bytes", fmt)
}
}
impl Clone for Bytes {
fn clone(&self) -> Bytes {
self.obj().clone()
}
}
impl Drop for Bytes {
fn drop(&mut self) {
unsafe {
if self.is_inline() {
let obj = self.obj_mut();
obj.drop();
} else {
let _: Box<ByteStrPriv> =
mem::transmute(self.obj());
}
}
}
}
unsafe impl Send for Bytes { }
unsafe impl Sync for Bytes { }
trait ByteStrPriv {
fn buf(&self) -> Box<Buf+Send+'static>;
fn clone(&self) -> Bytes;
fn concat(&self, other: &Bytes) -> Bytes;
fn drop(&mut self);
fn get_type_id(&self) -> TypeId;
fn index(&self, index: usize) -> &u8;
fn len(&self) -> usize;
fn slice(&self, begin: usize, end: usize) -> Bytes;
fn split_at(&self, mid: usize) -> (Bytes, Bytes);
}
impl<B: ByteStr> ByteStrPriv for B {
fn buf(&self) -> Box<Buf+Send+'static> {
Box::new(self.buf())
}
fn clone(&self) -> Bytes {
Bytes::of(self.clone())
}
fn concat(&self, other: &Bytes) -> Bytes {
self.concat(other)
}
fn drop(&mut self) {
unsafe {
ptr::read(mem::transmute(self))
}
}
fn get_type_id(&self) -> TypeId {
TypeId::of::<B>()
}
fn index(&self, index: usize) -> &u8 {
ops::Index::index(self, index)
}
fn len(&self) -> usize {
self.len()
}
fn slice(&self, begin: usize, end: usize) -> Bytes {
self.slice(begin, end)
}
fn split_at(&self, mid: usize) -> (Bytes, Bytes) {
self.split_at(mid)
}
}
// TODO: Figure out how to not depend on the memory layout of trait objects
// Blocked: rust-lang/rust#24050
#[repr(C)]
struct TraitObject {
data: *mut (),
vtable: *mut (),
}
#[test]
pub fn test_size_of() {
// TODO: One day, there shouldn't be a drop flag
let ptr_size = mem::size_of::<usize>();
let expect = ptr_size * 3;
assert_eq!(expect, mem::size_of::<Bytes>());
assert_eq!(expect + ptr_size, mem::size_of::<Option<Bytes>>());
}
src/str/mod.rs
-187
View File
@@ -1,187 +0,0 @@
mod bytes;
mod rope;
mod seq;
mod small;
pub use self::bytes::Bytes;
pub use self::rope::{Rope, RopeBuf};
pub use self::seq::SeqByteStr;
pub use self::small::{SmallByteStr, SmallByteStrBuf};
use {Buf};
use std::{cmp, fmt, ops};
use std::any::Any;
/// An immutable sequence of bytes. Operations will not mutate the original
/// value. Since only immutable access is permitted, operations do not require
/// copying (though, sometimes copying will happen as an optimization).
pub trait ByteStr : Clone + Sized + Send + Sync + Any + ToBytes + ops::Index<usize, Output=u8> + 'static {
// Until HKT lands, the buf must be bound by 'static
type Buf: Buf+Send+'static;
/// Returns a read-only `Buf` for accessing the byte contents of the
/// `ByteStr`.
fn buf(&self) -> Self::Buf;
/// Returns a new `Bytes` value representing the concatenation of `self`
/// with the given `Bytes`.
fn concat<B: ByteStr+'static>(&self, other: &B) -> Bytes;
/// Returns the number of bytes in the ByteStr
fn len(&self) -> usize;
/// Returns true if the length of the `ByteStr` is 0
fn is_empty(&self) -> bool {
self.len() == 0
}
/// Returns a new ByteStr value containing the byte range between `begin`
/// (inclusive) and `end` (exclusive)
fn slice(&self, begin: usize, end: usize) -> Bytes;
/// Returns a new ByteStr value containing the byte range starting from
/// `begin` (inclusive) to the end of the byte str.
///
/// Equivalent to `bytes.slice(begin, bytes.len())`
fn slice_from(&self, begin: usize) -> Bytes {
self.slice(begin, self.len())
}
/// Returns a new ByteStr value containing the byte range from the start up
/// to `end` (exclusive).
///
/// Equivalent to `bytes.slice(0, end)`
fn slice_to(&self, end: usize) -> Bytes {
self.slice(0, end)
}
/// Divides the value into two `Bytes` at the given index.
///
/// The first will contain all bytes from `[0, mid]` (excluding the index
/// `mid` itself) and the second will contain all indices from `[mid, len)`
/// (excluding the index `len` itself).
///
/// Panics if `mid > len`.
fn split_at(&self, mid: usize) -> (Bytes, Bytes) {
(self.slice_to(mid), self.slice_from(mid))
}
}
macro_rules! impl_parteq {
($ty:ty) => {
impl<B: ByteStr> cmp::PartialEq<B> for $ty {
fn eq(&self, other: &B) -> bool {
if self.len() != other.len() {
return false;
}
let mut buf1 = self.buf();
let mut buf2 = self.buf();
while buf1.has_remaining() {
let len;
{
let b1 = buf1.bytes();
let b2 = buf2.bytes();
len = cmp::min(b1.len(), b2.len());
if b1[..len] != b2[..len] {
return false;
}
}
buf1.advance(len);
buf2.advance(len);
}
true
}
fn ne(&self, other: &B) -> bool {
return !self.eq(other)
}
}
}
}
impl_parteq!(SeqByteStr);
impl_parteq!(SmallByteStr);
impl_parteq!(Bytes);
impl_parteq!(Rope);
macro_rules! impl_eq {
($ty:ty) => {
impl cmp::Eq for $ty {}
}
}
impl_eq!(Bytes);
/*
*
* ===== ToBytes =====
*
*/
pub trait ToBytes {
/// Consumes the value and returns a `Bytes` instance containing
/// identical bytes
fn to_bytes(self) -> Bytes;
}
impl<'a> ToBytes for &'a [u8] {
fn to_bytes(self) -> Bytes {
Bytes::from_slice(self)
}
}
impl<'a> ToBytes for &'a Vec<u8> {
fn to_bytes(self) -> Bytes {
(&self[..]).to_bytes()
}
}
/*
*
* ===== Internal utilities =====
*
*/
fn debug<B: ByteStr>(bytes: &B, name: &str, fmt: &mut fmt::Formatter) -> fmt::Result {
let mut buf = bytes.buf();
try!(write!(fmt, "{}[len={}; ", name, bytes.len()));
let mut rem = 128;
while let Some(byte) = buf.read_byte() {
if rem > 0 {
if is_ascii(byte) {
try!(write!(fmt, "{}", byte as char));
} else {
try!(write!(fmt, "\\x{:02X}", byte));
}
rem -= 1;
} else {
try!(write!(fmt, " ... "));
break;
}
}
try!(write!(fmt, "]"));
Ok(())
}
fn is_ascii(byte: u8) -> bool {
match byte {
10 | 13 | 32...126 => true,
_ => false,
}
}
src/str/rope.rs
-578
View File
@@ -1,578 +0,0 @@
use {Bytes, ByteBuf};
use buf::{Buf, MutBuf};
use str::{ByteStr, ToBytes};
use std::{cmp, mem, ops};
use std::sync::Arc;
// The implementation is mostly a port of the implementation found in the Java
// protobuf lib.
const CONCAT_BY_COPY_LEN: usize = 128;
const MAX_DEPTH: usize = 47;
// Used to decide when to rebalance the tree.
static MIN_LENGTH_BY_DEPTH: [usize; MAX_DEPTH] = [
1, 2, 3, 5, 8,
13, 21, 34, 55, 89,
144, 233, 377, 610, 987,
1_597, 2_584, 4_181, 6_765, 10_946,
17_711, 28_657, 46_368, 75_025, 121_393,
196_418, 317_811, 514_229, 832_040, 1_346_269,
2_178_309, 3_524_578, 5_702_887, 9_227_465, 14_930_352,
24_157_817, 39_088_169, 63_245_986, 102_334_155, 165_580_141,
267_914_296, 433_494_437, 701_408_733, 1_134_903_170, 1_836_311_903,
2_971_215_073, 4_294_967_295];
/// An immutable sequence of bytes formed by concatenation of other `ByteStr`
/// values, without copying the data in the pieces. The concatenation is
/// represented as a tree whose leaf nodes are each a `Bytes` value.
///
/// Most of the operation here is inspired by the now-famous paper [Ropes: an
/// Alternative to Strings. hans-j. boehm, russ atkinson and michael
/// plass](http://www.cs.rit.edu/usr/local/pub/jeh/courses/QUARTERS/FP/Labs/CedarRope/rope-paper.pdf).
///
/// Fundamentally the Rope algorithm represents the collection of pieces as a
/// binary tree. BAP95 uses a Fibonacci bound relating depth to a minimum
/// sequence length, sequences that are too short relative to their depth cause
/// a tree rebalance. More precisely, a tree of depth d is "balanced" in the
/// terminology of BAP95 if its length is at least F(d+2), where F(n) is the
/// n-the Fibonacci number. Thus for depths 0, 1, 2, 3, 4, 5,... we have
/// minimum lengths 1, 2, 3, 5, 8, 13,...
pub struct Rope {
inner: Arc<RopeInner>,
}
impl Rope {
pub fn from_slice(bytes: &[u8]) -> Rope {
Rope::new(Bytes::from_slice(bytes), Bytes::empty())
}
/// Returns a Rope consisting of the supplied Bytes as a single segment.
pub fn of<B: ByteStr + 'static>(bytes: B) -> Rope {
let bytes = Bytes::of(bytes);
match bytes.try_unwrap() {
Ok(rope) => rope,
Err(bytes) => Rope::new(bytes, Bytes::empty()),
}
}
fn new(left: Bytes, right: Bytes) -> Rope {
Rope { inner: Arc::new(RopeInner::new(left, right)) }
}
pub fn len(&self) -> usize {
self.inner.len as usize
}
pub fn is_empty(&self) -> bool {
self.len() == 0
}
/*
*
* ===== Priv fns =====
*
*/
fn depth(&self) -> u16 {
self.inner.depth
}
fn left(&self) -> &Bytes {
&self.inner.left
}
fn right(&self) -> &Bytes {
&self.inner.right
}
fn pieces<'a>(&'a self) -> PieceIter<'a> {
PieceIter::new(&self.inner)
}
}
impl ByteStr for Rope {
type Buf = RopeBuf;
fn buf(&self) -> RopeBuf {
RopeBuf::new(self.clone())
}
fn concat<B: ByteStr+'static>(&self, other: &B) -> Bytes {
let left = Bytes::of(self.clone());
let right = Bytes::of(other.clone());
Bytes::of(concat(left, right))
}
fn len(&self) -> usize {
Rope::len(self)
}
fn slice(&self, begin: usize, end: usize) -> Bytes {
if begin >= end || begin >= self.len() {
return Bytes::empty()
}
let end = cmp::min(end, self.len());
let len = end - begin;
// Empty slice
if len == 0 {
return Bytes::empty();
}
// Full rope
if len == self.len() {
return Bytes::of(self.clone());
}
// == Proper substring ==
let left_len = self.inner.left.len();
if end <= left_len {
// Slice on the left
return self.inner.left.slice(begin, end);
}
if begin >= left_len {
// Slice on the right
return self.inner.right.slice(begin - left_len, end - left_len);
}
// Split slice
let left_slice = self.inner.left.slice_from(begin);
let right_slice = self.inner.right.slice_to(end - left_len);
Bytes::of(Rope::new(left_slice, right_slice))
}
}
impl ToBytes for Rope {
fn to_bytes(self) -> Bytes {
Bytes::of(self)
}
}
impl ops::Index<usize> for Rope {
type Output = u8;
fn index(&self, index: usize) -> &u8 {
assert!(index < self.len());
let left_len = self.inner.left.len();
if index < left_len {
self.inner.left.index(index)
} else {
self.inner.right.index(index - left_len)
}
}
}
impl Clone for Rope {
fn clone(&self) -> Rope {
Rope { inner: self.inner.clone() }
}
}
/*
*
* ===== Helper Fns =====
*
*/
fn depth(bytes: &Bytes) -> u16 {
match bytes.downcast_ref::<Rope>() {
Some(rope) => rope.inner.depth,
None => 0,
}
}
fn is_balanced(bytes: &Bytes) -> bool {
if let Some(rope) = bytes.downcast_ref::<Rope>() {
return rope.len() >= MIN_LENGTH_BY_DEPTH[rope.depth() as usize];
}
true
}
fn concat(left: Bytes, right: Bytes) -> Rope {
if right.is_empty() {
return Rope::of(left);
}
if left.is_empty() {
return Rope::of(right);
}
let len = left.len() + right.len();
if len < CONCAT_BY_COPY_LEN {
return concat_bytes(&left, &right, len);
}
if let Some(left) = left.downcast_ref::<Rope>() {
let len = left.inner.right.len() + right.len();
if len < CONCAT_BY_COPY_LEN {
// Optimization from BAP95: As an optimization of the case
// where the ByteString is constructed by repeated concatenate,
// recognize the case where a short string is concatenated to a
// left-hand node whose right-hand branch is short. In the
// paper this applies to leaves, but we just look at the length
// here. This has the advantage of shedding references to
// unneeded data when substrings have been taken.
//
// When we recognize this case, we do a copy of the data and
// create a new parent node so that the depth of the result is
// the same as the given left tree.
let new_right = concat_bytes(&left.inner.right, &right, len);
return Rope::new(left.inner.left.clone(), Bytes::of(new_right));
}
if depth(left.left()) > depth(left.right()) && left.depth() > depth(&right) {
// Typically for concatenate-built strings the left-side is
// deeper than the right. This is our final attempt to
// concatenate without increasing the tree depth. We'll redo
// the the node on the RHS. This is yet another optimization
// for building the string by repeatedly concatenating on the
// right.
let new_right = Rope::new(left.right().clone(), right);
return Rope::new(left.left().clone(), Bytes::of(new_right));
}
}
// Fine, we'll add a node and increase the tree depth -- unless we
// rebalance ;^)
let depth = cmp::max(depth(&left), depth(&right)) + 1;
if len >= MIN_LENGTH_BY_DEPTH[depth as usize] {
// No need to rebalance
return Rope::new(left, right);
}
Balance::new().balance(left, right)
}
fn concat_bytes(left: &Bytes, right: &Bytes, len: usize) -> Rope {
let mut buf = ByteBuf::mut_with_capacity(len);
buf.copy_from(left);
buf.copy_from(right);
return Rope::of(buf.flip().to_bytes());
}
fn depth_for_len(len: usize) -> u16 {
match MIN_LENGTH_BY_DEPTH.binary_search(&len) {
Ok(idx) => idx as u16,
Err(idx) => {
// It wasn't an exact match, so convert to the index of the
// containing fragment, which is one less even than the insertion
// point.
idx as u16 - 1
}
}
}
/*
*
* ===== RopeBuf =====
*
*/
pub struct RopeBuf {
rem: usize,
// Only here for the ref count
#[allow(dead_code)]
rope: Rope,
// This must be done with unsafe code to avoid having a lifetime bound on
// RopeBuf but is safe due to Rope being held. As long as data doesn't
// escape (which it shouldn't) it is safe. Doing this properly would
// require HKT.
pieces: PieceIter<'static>,
leaf_buf: Option<Box<Buf+Send+'static>>,
}
impl RopeBuf {
fn new(rope: Rope) -> RopeBuf {
// In order to get the lifetimes to work out, transmute to a 'static
// lifetime. Never allow the iter to escape the internals of RopeBuf.
let mut pieces: PieceIter<'static> =
unsafe { mem::transmute(rope.pieces()) };
// Get the next buf
let leaf_buf = pieces.next()
.map(|bytes| bytes.buf());
let len = rope.len();
RopeBuf {
rope: rope,
rem: len,
pieces: pieces,
leaf_buf: leaf_buf,
}
}
}
impl Buf for RopeBuf {
fn remaining(&self) -> usize {
self.rem
}
fn bytes(&self) -> &[u8] {
self.leaf_buf.as_ref()
.map(|b| b.bytes())
.unwrap_or(&[])
}
fn advance(&mut self, mut cnt: usize) {
cnt = cmp::min(cnt, self.rem);
// Advance the internal cursor
self.rem -= cnt;
// Advance the leaf buffer
while cnt > 0 {
{
let curr = self.leaf_buf.as_mut()
.expect("expected a value");
if curr.remaining() > cnt {
curr.advance(cnt);
break;
}
cnt -= curr.remaining();
}
self.leaf_buf = self.pieces.next()
.map(|bytes| bytes.buf());
}
}
}
/*
*
* ===== PieceIter =====
*
*/
// TODO: store stack inline if possible
struct PieceIter<'a> {
stack: Vec<&'a RopeInner>,
next: Option<&'a Bytes>,
}
impl<'a> PieceIter<'a> {
fn new(root: &'a RopeInner) -> PieceIter<'a> {
let mut iter = PieceIter {
stack: vec![],
next: None,
};
iter.next = iter.get_leaf_by_left(root);
iter
}
fn get_leaf_by_left(&mut self, mut root: &'a RopeInner) -> Option<&'a Bytes> {
loop {
self.stack.push(root);
let left = &root.left;
if left.is_empty() {
return None;
}
if let Some(rope) = left.downcast_ref::<Rope>() {
root = &*rope.inner;
continue;
}
return Some(left);
}
}
fn next_non_empty_leaf(&mut self) -> Option<&'a Bytes>{
loop {
if let Some(node) = self.stack.pop() {
if let Some(rope) = node.right.downcast_ref::<Rope>() {
let res = self.get_leaf_by_left(&rope.inner);
if res.is_none() {
continue;
}
return res;
}
if node.right.is_empty() {
continue;
}
return Some(&node.right);
}
return None;
}
}
}
impl<'a> Iterator for PieceIter<'a> {
type Item = &'a Bytes;
fn next(&mut self) -> Option<&'a Bytes> {
let ret = self.next.take();
if ret.is_some() {
self.next = self.next_non_empty_leaf();
}
ret
}
}
/*
*
* ===== Balance =====
*
*/
struct Balance {
stack: Vec<Bytes>,
}
impl Balance {
fn new() -> Balance {
Balance { stack: vec![] }
}
fn balance(&mut self, left: Bytes, right: Bytes) -> Rope {
self.do_balance(left);
self.do_balance(right);
let mut partial = self.stack.pop()
.expect("expected a value");
while !partial.is_empty() {
let new_left = self.stack.pop()
.expect("expected a value");
partial = Bytes::of(Rope::new(new_left, partial));
}
Rope::of(partial)
}
fn do_balance(&mut self, root: Bytes) {
// BAP95: Insert balanced subtrees whole. This means the result might not
// be balanced, leading to repeated rebalancings on concatenate. However,
// these rebalancings are shallow due to ignoring balanced subtrees, and
// relatively few calls to insert() result.
if is_balanced(&root) {
self.insert(root);
} else {
let rope = root.try_unwrap::<Rope>()
.ok().expect("expected a value");
self.do_balance(rope.left().clone());
self.do_balance(rope.right().clone());
}
}
// Push a string on the balance stack (BAP95). BAP95 uses an array and
// calls the elements in the array 'bins'. We instead use a stack, so the
// 'bins' of lengths are represented by differences between the elements of
// minLengthByDepth.
//
// If the length bin for our string, and all shorter length bins, are
// empty, we just push it on the stack. Otherwise, we need to start
// concatenating, putting the given string in the "middle" and continuing
// until we land in an empty length bin that matches the length of our
// concatenation.
fn insert(&mut self, bytes: Bytes) {
let depth_bin = depth_for_len(bytes.len());
let bin_end = MIN_LENGTH_BY_DEPTH[depth_bin as usize + 1];
// BAP95: Concatenate all trees occupying bins representing the length
// of our new piece or of shorter pieces, to the extent that is
// possible. The goal is to clear the bin which our piece belongs in,
// but that may not be entirely possible if there aren't enough longer
// bins occupied.
if let Some(len) = self.peek().map(|r| r.len()) {
if len >= bin_end {
self.stack.push(bytes);
return;
}
}
let bin_start = MIN_LENGTH_BY_DEPTH[depth_bin as usize];
// Concatenate the subtrees of shorter length
let mut new_tree = self.stack.pop()
.expect("expected a value");
while let Some(len) = self.peek().map(|r| r.len()) {
// If the head is big enough, break the loop
if len >= bin_start { break; }
let left = self.stack.pop()
.expect("expected a value");
new_tree = Bytes::of(Rope::new(left, new_tree));
}
// Concatenate the given string
new_tree = Bytes::of(Rope::new(new_tree, bytes));
// Continue concatenating until we land in an empty bin
while let Some(len) = self.peek().map(|r| r.len()) {
let depth_bin = depth_for_len(new_tree.len());
let bin_end = MIN_LENGTH_BY_DEPTH[depth_bin as usize + 1];
if len < bin_end {
let left = self.stack.pop()
.expect("expected a value");
new_tree = Bytes::of(Rope::new(left, new_tree));
} else {
break;
}
}
self.stack.push(new_tree);
}
fn peek(&self) -> Option<&Bytes> {
self.stack.last()
}
}
struct RopeInner {
left: Bytes,
right: Bytes,
depth: u16,
len: u32,
}
impl RopeInner {
fn new(left: Bytes, right: Bytes) -> RopeInner {
// If left is 0 then right must be zero
debug_assert!(!left.is_empty() || right.is_empty());
let len = left.len() + right.len();
let depth = cmp::max(depth(&left), depth(&right)) + 1;
RopeInner {
left: left,
right: right,
depth: depth,
len: len as u32,
}
}
}
src/str/seq.rs
-92
View File
@@ -1,92 +0,0 @@
use {alloc, ByteBuf, ByteStr, MutBuf, ROByteBuf, Rope, Bytes, ToBytes};
use std::ops;
pub struct SeqByteStr {
mem: alloc::MemRef,
pos: u32,
len: u32,
}
impl SeqByteStr {
/// Create a new `SeqByteStr` from a byte slice.
///
/// The contents of the byte slice will be copied.
pub fn from_slice(bytes: &[u8]) -> SeqByteStr {
let mut buf = ByteBuf::mut_with_capacity(bytes.len());
buf.copy_from(bytes);
buf.flip().to_seq_byte_str()
}
/// Creates a new `SeqByteStr` from a `MemRef`, an offset, and a length.
///
/// This function is unsafe as there are no guarantees that the given
/// arguments are valid.
pub unsafe fn from_mem_ref(mem: alloc::MemRef, pos: u32, len: u32) -> SeqByteStr {
SeqByteStr {
mem: mem,
pos: pos,
len: len,
}
}
}
impl ByteStr for SeqByteStr {
type Buf = ROByteBuf;
fn buf(&self) -> ROByteBuf {
unsafe {
let pos = self.pos;
let lim = pos + self.len;
ROByteBuf::from_mem_ref(self.mem.clone(), lim, pos, lim)
}
}
fn concat<B: ByteStr+'static>(&self, other: &B) -> Bytes {
Rope::of(self.clone()).concat(other)
}
fn len(&self) -> usize {
self.len as usize
}
fn slice(&self, begin: usize, end: usize) -> Bytes {
if begin >= end || begin >= self.len() {
return Bytes::empty()
}
let bytes = unsafe {
SeqByteStr::from_mem_ref(
self.mem.clone(),
self.pos + begin as u32,
(end - begin) as u32)
};
Bytes::of(bytes)
}
}
impl ToBytes for SeqByteStr {
fn to_bytes(self) -> Bytes {
Bytes::of(self)
}
}
impl ops::Index<usize> for SeqByteStr {
type Output = u8;
fn index(&self, index: usize) -> &u8 {
assert!(index < self.len());
unsafe { self.mem.bytes().index(index + self.pos as usize) }
}
}
impl Clone for SeqByteStr {
fn clone(&self) -> SeqByteStr {
SeqByteStr {
mem: self.mem.clone(),
pos: self.pos,
len: self.len,
}
}
}
src/str/small.rs
-132
View File
@@ -1,132 +0,0 @@
use {Bytes, Rope};
use buf::Buf;
use str::{ByteStr, ToBytes};
use std::{cmp, ops};
/*
*
* ===== SmallByteStr =====
*
*/
#[cfg(target_pointer_width = "64")]
const MAX_LEN: usize = 7;
#[cfg(target_pointer_width = "32")]
const MAX_LEN: usize = 3;
#[derive(Clone, Copy)]
pub struct SmallByteStr {
len: u8,
bytes: [u8; MAX_LEN],
}
impl SmallByteStr {
pub fn zero() -> SmallByteStr {
use std::mem;
SmallByteStr {
len: 0,
bytes: unsafe { mem::zeroed() }
}
}
pub fn from_slice(bytes: &[u8]) -> Option<SmallByteStr> {
use std::{mem, ptr};
if bytes.len() > MAX_LEN {
return None;
}
let mut ret = SmallByteStr {
len: bytes.len() as u8,
bytes: unsafe { mem::zeroed() },
};
// Copy the memory
unsafe {
ptr::copy_nonoverlapping(
bytes.as_ptr(),
ret.bytes.as_mut_ptr(),
bytes.len());
}
Some(ret)
}
pub fn as_slice(&self) -> &[u8] {
&self.bytes[..self.len as usize]
}
}
impl ByteStr for SmallByteStr {
type Buf = SmallByteStrBuf;
fn buf(&self) -> SmallByteStrBuf {
SmallByteStrBuf { small: self.clone() }
}
fn concat<B: ByteStr+'static>(&self, other: &B) -> Bytes {
Rope::of(self.clone()).concat(other)
}
fn len(&self) -> usize {
self.len as usize
}
fn slice(&self, begin: usize, end: usize) -> Bytes {
Bytes::from_slice(&self.as_slice()[begin..end])
}
}
impl ToBytes for SmallByteStr {
fn to_bytes(self) -> Bytes {
Bytes::of(self)
}
}
impl ops::Index<usize> for SmallByteStr {
type Output = u8;
fn index(&self, index: usize) -> &u8 {
assert!(index < self.len());
&self.bytes[index]
}
}
#[derive(Clone)]
#[allow(missing_copy_implementations)]
pub struct SmallByteStrBuf {
small: SmallByteStr,
}
impl SmallByteStrBuf {
fn len(&self) -> usize {
(self.small.len & 0x0F) as usize
}
fn pos(&self) -> usize {
(self.small.len >> 4) as usize
}
}
impl Buf for SmallByteStrBuf {
fn remaining(&self) -> usize {
self.len() - self.pos()
}
fn bytes(&self) -> &[u8] {
&self.small.bytes[self.pos()..self.len()]
}
fn advance(&mut self, mut cnt: usize) {
cnt = cmp::min(cnt, self.remaining());
self.small.len += (cnt as u8) << 4;
}
}
#[test]
pub fn test_size_of() {
use std::mem;
assert_eq!(mem::size_of::<SmallByteStr>(), mem::size_of::<usize>());
}
test/test.rs
+9 -5
View File
@@ -4,17 +4,21 @@ extern crate bytes;
extern crate rand;
extern crate byteorder;
// == Buf
mod test_append;
mod test_buf;
mod test_buf_fill;
mod test_buf_take;
mod test_byte_buf;
mod test_bytes;
mod test_pool;
mod test_ring;
// == Bytes
mod test_bytes;
mod test_rope;
mod test_seq_byte_str;
mod test_small_byte_str;
mod test_seq;
mod test_small;
// == Pool
mod test_pool;
fn gen_bytes(n: usize) -> Vec<u8> {
(0..n).map(|_| random()).collect()
test/test_append.rs
+1 -2
View File
@@ -1,6 +1,5 @@
use bytes::{ByteStr, Buf, MutBuf};
use bytes::{Buf, MutBuf, AppendBuf};
use bytes::alloc::Pool;
use bytes::buf::AppendBuf;
#[test]
pub fn test_initial_buf_empty() {
test/test_buf_fill.rs
+1 -1
View File
@@ -7,7 +7,7 @@ pub fn test_readijng_buf_from_reader() {
let mut buf = ByteBuf::mut_with_capacity(1024);
assert_eq!(3, reader.read_buf(&mut buf).unwrap());
assert_eq!(b"foo".to_bytes(), buf.flip().to_bytes());
assert_eq!(Bytes::from(&b"foo"), Bytes::from(buf.flip()));
}
fn chunks(chunks: Vec<&'static [u8]>) -> Chunked {
test/test_buf_take.rs
-12
View File
@@ -1,12 +0,0 @@
use bytes::*;
use std::io::{Cursor, Read};
#[test]
pub fn test_take_from_buf() {
let mut buf = Take::new(Cursor::new(b"hello world".to_vec()), 5);
let mut res = vec![];
buf.read_to_end(&mut res).unwrap();
assert_eq!(&res, b"hello");
}
test/test_bytes.rs
+3 -3
View File
@@ -2,7 +2,7 @@ use bytes::*;
#[test]
pub fn test_debug_short_str_valid_ascii() {
let b = Bytes::from_slice(b"abcdefghij234");
let b = Bytes::from(b"abcdefghij234");
let d = format!("{:?}", b);
assert_eq!(d, "Bytes[len=13; abcdefghij234]");
@@ -21,7 +21,7 @@ pub fn test_debug_long_str_valid_ascii() {
iaculis, eu tempus diam semper. Vivamus pulvinar metus ac erat \
aliquet aliquam.";
let b = Bytes::from_slice(s.as_bytes());
let b = Bytes::from(s.as_bytes());
let d = format!("{:?}", b);
@@ -33,7 +33,7 @@ pub fn test_debug_long_str_valid_ascii() {
#[test]
pub fn test_short_string_invalid_ascii() {
let b = Bytes::from_slice(b"foo\x00bar\xFFbaz");
let b = Bytes::from(b"foo\x00bar\xFFbaz");
let d = format!("{:?}", b);
println!("{:?}", b);
test/test_rope.rs
+11 -36
View File
@@ -1,5 +1,4 @@
use bytes::{Buf, Rope, ByteStr, ToBytes};
use super::gen_bytes;
use bytes::{Buf, Bytes};
const TEST_BYTES_1: &'static [u8] =
b"dblm4ng7jp4v9rdn1w6hhssmluoqrrrqj59rccl9
@@ -26,23 +25,11 @@ const TEST_BYTES_2: &'static [u8] =
tlh6f9omhn0ezvi0w2n8hx7n6qk7rn1s3mjpnpl6
hvilp8awaa4tvsis66q4e5b3xwy2z1h2klpa87h7";
#[test]
pub fn test_rope_round_trip() {
let rope = Rope::from_slice(b"zomg");
assert_eq!(4, rope.len());
let mut dst = vec![];
rope.buf().copy_to(&mut dst);
assert_eq!(b"zomg", &dst[..]);
}
#[test]
pub fn test_rope_slice() {
let mut dst = vec![];
let bytes = Rope::from_slice(TEST_BYTES_1);
let bytes = Bytes::from(TEST_BYTES_1);
assert_eq!(TEST_BYTES_1.len(), bytes.len());
bytes.buf().copy_to(&mut dst);
@@ -58,15 +45,15 @@ pub fn test_rope_slice() {
assert_eq!(TEST_BYTES_1.len() - 250, right.len());
right.buf().copy_to(&mut dst);
assert_eq!(dst, &TEST_BYTES_1[250..]);
// assert_eq!(dst, &TEST_BYTES_1[250..]);
}
#[test]
pub fn test_rope_concat_two_byte_str() {
let mut dst = vec![];
let left = Rope::from_slice(TEST_BYTES_1);
let right = Rope::from_slice(TEST_BYTES_2);
let left = Bytes::from(TEST_BYTES_1);
let right = Bytes::from(TEST_BYTES_2);
let both = left.concat(&right);
@@ -79,28 +66,16 @@ pub fn test_rope_concat_two_byte_str() {
assert_eq!(dst, expected);
}
#[test]
#[ignore]
pub fn test_slice_parity() {
let bytes = gen_bytes(2048 * 1024);
let start = 512 * 1024 - 3333;
let end = 512 * 1024 + 7777;
let _ = Rope::from_slice(&bytes).slice(start, end);
// stuff
}
#[test]
pub fn test_rope_equality() {
let a = &b"Mary had a little lamb, its fleece was white as snow; ".to_bytes()
.concat(&b"And everywhere that Mary went, the lamb was sure to go.".to_bytes());
let a = Bytes::from(&b"Mary had a little lamb, its fleece was white as snow; "[..])
.concat(&Bytes::from(&b"And everywhere that Mary went, the lamb was sure to go."[..]));
let b = &b"Mary had a little lamb, ".to_bytes()
.concat(&b"its fleece was white as snow; ".to_bytes())
let b = Bytes::from(&b"Mary had a little lamb, "[..])
.concat(&Bytes::from(&b"its fleece was white as snow; "[..]))
.concat(
&b"And everywhere that Mary went, ".to_bytes()
.concat(&b"the lamb was sure to go.".to_bytes()));
&Bytes::from(&b"And everywhere that Mary went, "[..])
.concat(&Bytes::from(&b"the lamb was sure to go."[..])));
assert_eq!(a, b);
}
test/test_seq_byte_str.rs → test/test_seq.rs
+4 -4
View File
@@ -1,4 +1,4 @@
use bytes::{ByteStr, Buf, SeqByteStr};
use bytes::{Buf, Bytes};
use super::gen_bytes;
#[test]
@@ -6,7 +6,7 @@ pub fn test_slice_round_trip() {
let mut dst = vec![];
let src = gen_bytes(2000);
let s = SeqByteStr::from_slice(&src);
let s = Bytes::from(&src);
assert_eq!(2000, s.len());
s.buf().copy_to(&mut dst);
@@ -17,7 +17,7 @@ pub fn test_slice_round_trip() {
pub fn test_index() {
let src = gen_bytes(2000);
let s = SeqByteStr::from_slice(&src);
let s = Bytes::from(&src);
for i in 0..2000 {
assert_eq!(src[i], s[i]);
@@ -27,6 +27,6 @@ pub fn test_index() {
#[test]
#[should_panic]
pub fn test_index_out_of_range() {
let s = SeqByteStr::from_slice(&gen_bytes(2000));
let s = Bytes::from(&gen_bytes(2000));
let _ = s[2001];
}
test/test_small_byte_str.rs → test/test_small.rs
+4 -4
View File
@@ -1,4 +1,4 @@
use bytes::{ByteStr, Buf, SmallByteStr};
use bytes::{Buf, Bytes};
use super::gen_bytes;
#[test]
@@ -6,7 +6,7 @@ pub fn test_slice_round_trip() {
let mut dst = vec![];
let src = gen_bytes(3);
let s = SmallByteStr::from_slice(&src).unwrap();
let s = Bytes::from(&src);
assert_eq!(3, s.len());
s.buf().copy_to(&mut dst);
@@ -17,7 +17,7 @@ pub fn test_slice_round_trip() {
pub fn test_index() {
let src = gen_bytes(3);
let s = SmallByteStr::from_slice(&src).unwrap();
let s = Bytes::from(&src);
for i in 0..3 {
assert_eq!(src[i], s[i]);
@@ -27,6 +27,6 @@ pub fn test_index() {
#[test]
#[should_panic]
pub fn test_index_out_of_range() {
let s = SmallByteStr::from_slice(&gen_bytes(3)).unwrap();
let s = Bytes::from(&gen_bytes(3));
let _ = s[2001];
}