mirror of
https://github.com/tokio-rs/bytes.git
synced 2026-08-16 00:00:15 +02:00
Group files as buf or byte str related
This commit is contained in:
Carl Lerche
@@ -0,0 +1,235 @@
|
||||
use {alloc, Bytes, ByteBuf, ROByteBuf, Rope};
|
||||
use traits::{Buf, MutBuf, MutBufExt, ByteStr, ToBytes};
|
||||
use std::{cmp, ops};
|
||||
|
||||
/*
|
||||
*
|
||||
* ===== SeqByteStr =====
|
||||
*
|
||||
*/
|
||||
|
||||
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());
|
||||
|
||||
if let Err(e) = buf.write(bytes) {
|
||||
panic!("failed to copy bytes from slice; err={:?}", e);
|
||||
}
|
||||
|
||||
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.ptr()
|
||||
.offset(index as isize + self.pos as isize)
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
impl Clone for SeqByteStr {
|
||||
fn clone(&self) -> SeqByteStr {
|
||||
SeqByteStr {
|
||||
mem: self.mem.clone(),
|
||||
pos: self.pos,
|
||||
len: self.len,
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
/*
|
||||
*
|
||||
* ===== 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>());
|
||||
}
|
||||
@@ -0,0 +1,308 @@
|
||||
use {ByteBuf, MutBuf, SmallByteStr, Source, BufError};
|
||||
use traits::{Buf, ByteStr, ToBytes};
|
||||
use std::{cmp, fmt, mem, ops, ptr};
|
||||
use std::any::{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 mut vtable;
|
||||
let mut 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 mut 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 {
|
||||
let obj = 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),
|
||||
}
|
||||
};
|
||||
|
||||
mem::transmute(obj)
|
||||
}
|
||||
}
|
||||
|
||||
fn obj_mut(&mut self) -> &mut ByteStrPriv {
|
||||
unsafe { mem::transmute(self.obj()) }
|
||||
}
|
||||
|
||||
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+'static>;
|
||||
|
||||
fn buf(&self) -> Box<Buf+'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 { }
|
||||
|
||||
impl<'a> Source for &'a Bytes {
|
||||
type Error = BufError;
|
||||
|
||||
fn fill<B: MutBuf>(self, dst: &mut B) -> Result<usize, BufError> {
|
||||
let mut src = ByteStr::buf(self);
|
||||
let mut res = 0;
|
||||
|
||||
while src.has_remaining() && dst.has_remaining() {
|
||||
let mut l;
|
||||
|
||||
{
|
||||
let s = src.bytes();
|
||||
let d = dst.mut_bytes();
|
||||
l = cmp::min(s.len(), d.len());
|
||||
|
||||
unsafe {
|
||||
ptr::copy_nonoverlapping(
|
||||
s.as_ptr(),
|
||||
d.as_mut_ptr(),
|
||||
l);
|
||||
}
|
||||
}
|
||||
|
||||
src.advance(l);
|
||||
dst.advance(l);
|
||||
|
||||
res += l;
|
||||
}
|
||||
|
||||
Ok(res)
|
||||
}
|
||||
}
|
||||
|
||||
trait ByteStrPriv {
|
||||
|
||||
fn buf(&self) -> Box<Buf+'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+'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>>());
|
||||
}
|
||||
+185
@@ -0,0 +1,185 @@
|
||||
mod byte_str;
|
||||
mod bytes;
|
||||
mod rope;
|
||||
|
||||
pub use self::byte_str::{SeqByteStr, SmallByteStr, SmallByteStrBuf};
|
||||
pub use self::bytes::Bytes;
|
||||
pub use self::rope::{Rope, RopeBuf};
|
||||
|
||||
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+'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,
|
||||
}
|
||||
}
|
||||
+585
@@ -0,0 +1,585 @@
|
||||
use {Bytes, ByteBuf, Source, BufError};
|
||||
use traits::{Buf, ByteStr, MutBuf, MutBufExt, 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() }
|
||||
}
|
||||
}
|
||||
|
||||
impl<'a> Source for &'a Rope {
|
||||
type Error = BufError;
|
||||
|
||||
fn fill<B: MutBuf>(self, _buf: &mut B) -> Result<usize, BufError> {
|
||||
unimplemented!();
|
||||
}
|
||||
}
|
||||
|
||||
/*
|
||||
*
|
||||
* ===== 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.write(left).ok().expect("unexpected error");
|
||||
buf.write(right).ok().expect("unexpected error");
|
||||
|
||||
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+'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,
|
||||
}
|
||||
}
|
||||
}
|
||||
Reference in New Issue
Block a user