Huge overhaul of bytes

* Get rid of `ByteStr` trait
* `Bytes` is not a concrete type
* Add `BlockBuf`
* Delete lots of cruft
* Performance work

Cargo.toml

@@ -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

@@ -1,34 +1,49 @@
-#![feature(test, core)]
+#![feature(test)]
 
 use bytes::ByteBuf;
-use bytes::traits::*;
+use bytes::alloc::Pool;
-use iobuf::{RWIobuf};
 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 {
+        for _ in 0..200 {
-            buf.write_slice(&[0]);
+            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 {
+        for _ in 0..200 {
-            let _ = buf.fill(&[0]);
+            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

@@ -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(len: usize) -> MemRef {
-    pub fn allocate(&self, len: usize) -> MemRef {
+    // Make sure that the allocation is within the permitted range
-        // Make sure that the allocation is within the permitted range
+    if len > MAX_ALLOC_SIZE {
-        if len > MAX_ALLOC_SIZE {
+        return MemRef::none();
-            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)
-        }
     }
 
-    fn deallocate(ptr: *mut u8) {
+    unsafe {
-        unsafe {
+        let mut ptr = heap::allocate(alloc_len(len), align());
-            let off = mem::size_of::<Allocation>() + mem::size_of::<&Mem>();
+        let mut off = 0;
-            let len = ptr::read(ptr.offset(off as isize) as *const usize);
 
-            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

@@ -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 {
+/// Ref-counted segment of memory
-    Heap.allocate(len)
-}
-
 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

@@ -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

@@ -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 {
+        unsafe { AppendBuf::from_mem_ref(mem, capacity, 0) }
-            mem: mem,
-            rd: Cell::new(0),
-            wr: 0,
-            cap: capacity,
-        }
     }
 
     /// 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 {
+        let rd = self.rd.get() as usize;
-            return Bytes::of(SmallByteStr::zero());
+        let wr = self.wr as usize;
-        }
 
-        if let Some(bytes) = SmallByteStr::from_slice(&self.bytes()[begin..end]) {
+        assert!(begin <= end && end <= wr - rd, "invalid range");
-            return Bytes::of(bytes);
-        }
 
-        let begin = cmp::min(self.wr, begin as u32 + self.rd.get());
+        let begin = (begin + rd) as u32;
-        let end = cmp::min(self.wr, end as u32 + self.rd.get());
+        let end = (end + rd) as u32;
 
-        let bytes = unsafe { SeqByteStr::from_mem_ref(self.mem.clone(), begin, end - begin) };
+        unsafe { Bytes::from_mem_ref(self.mem.clone(), begin, end - begin) }
-
-        Bytes::of(bytes)
     }
 }
 
 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

@@ -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

@@ -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 {
+    pub fn read_slice(&mut self, dst: &mut [u8]) {
-        let len = cmp::min(dst.len(), self.remaining());
+        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 {
+impl From<ByteBuf> for Bytes {
-    fn fmt(&self, fmt: &mut fmt::Formatter) -> fmt::Result {
+    fn from(src: ByteBuf) -> Bytes {
-        self.bytes().fmt(fmt)
+        unsafe {
-    }
+            let ByteBuf { mem, pos, lim, .. } = src;
-}
+            Bytes::from_mem_ref(mem, pos, lim - pos)
-
-/*
- *
- * ===== 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)
         }
     }
-
-    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 {
+impl fmt::Debug for ByteBuf {
-
-    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 {
     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

@@ -1,16 +1,10 @@
-mod append;
+pub mod append;
-mod byte;
+pub mod block;
-mod ring;
+pub mod byte;
-mod sink;
+pub mod ring;
-mod source;
+pub mod take;
-mod take;
 
-pub use self::append::AppendBuf;
+use {Bytes};
-pub use self::byte::{ByteBuf, MutByteBuf, ROByteBuf};
-pub use self::ring::RingBuf;
-pub use self::take::Take;
-
-use {ByteStr, RopeBuf};
 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.has_remaining() {
-
+            let mut dst = [0];
-        if self.read_slice(&mut dst) == 0 {
+            self.read_slice(&mut dst);
-            return None;
+            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 {
+    fn copy_to<B: MutBuf>(self, buf: &mut B) {
-        buf.write_slice(self)
+        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 {
+impl Source for Bytes {
-    fn copy_to<B: MutBuf>(self, buf: &mut B) -> usize {
+    fn copy_to<B: MutBuf>(self, buf: &mut B) {
-        let mut src = ByteStr::buf(self);
+        Source::copy_to(&self, buf);
-        let mut res = 0;
+    }
+}
 
-        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 {
+    fn copy_from<B: Buf>(self, buf: &mut B) {
-        buf.read_slice(self)
+        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));
+                buf.read_slice(slice::from_raw_parts_mut(dst.as_mut_ptr(), rem));
-
-                debug_assert!(cnt == 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 {
+pub struct Fmt<'a, B: 'a>(pub &'a mut B);
-    ($ty:ty) => {
-        impl io::Read for $ty {
-            fn read(&mut self, buf: &mut [u8]) -> io::Result<usize> {
-                if !self.has_remaining() {
-                    return Ok(0);
-                }
 
-                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

@@ -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/take.rs

@@ -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

@@ -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

@@ -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

@@ -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

@@ -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

@@ -3,31 +3,21 @@
 
 extern crate stable_heap;
 
-pub mod alloc;
+#[macro_use]
-pub mod buf;
+extern crate log;
-pub mod str;
 
-pub use buf::{
+mod buf;
-    Buf,
+mod bytes;
-    MutBuf,
+
-    ByteBuf,
+pub mod alloc;
-    MutByteBuf,
+
-    RingBuf,
+pub use buf::{Buf, MutBuf, Source, Sink, ReadExt, WriteExt, Fmt};
-    ROByteBuf,
+pub use buf::append::AppendBuf;
-    Take,
+pub use buf::block::{BlockBuf, NewBlock, BlockBufCursor};
-    ReadExt,
+pub use buf::byte::{ByteBuf, MutByteBuf};
-    WriteExt,
+pub use buf::ring::RingBuf;
-};
+pub use buf::take::Take;
-pub use str::{
+pub use bytes::Bytes;
-    ByteStr,
-    Bytes,
-    Rope,
-    RopeBuf,
-    SeqByteStr,
-    SmallByteStr,
-    SmallByteStrBuf,
-    ToBytes,
-};
 
 use std::u32;
 

src/str/bytes.rs

@@ -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

@@ -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

@@ -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

@@ -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

@@ -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

@@ -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_seq;
-mod test_small_byte_str;
+mod test_small;
+
+// == Pool
+mod test_pool;
 
 fn gen_bytes(n: usize) -> Vec<u8> {
     (0..n).map(|_| random()).collect()

test/test_append.rs

@@ -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

@@ -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

@@ -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

@@ -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

@@ -1,5 +1,4 @@
-use bytes::{Buf, Rope, ByteStr, ToBytes};
+use bytes::{Buf, Bytes};
-use super::gen_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 left = Bytes::from(TEST_BYTES_1);
-    let right = Rope::from_slice(TEST_BYTES_2);
+    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()
+    let a = Bytes::from(&b"Mary had a little lamb, its fleece was white as snow; "[..])
-        .concat(&b"And everywhere that Mary went, the lamb was sure to go.".to_bytes());
+        .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()
+    let b = Bytes::from(&b"Mary had a little lamb, "[..])
-        .concat(&b"its fleece was white as snow; ".to_bytes())
+        .concat(&Bytes::from(&b"its fleece was white as snow; "[..]))
         .concat(
-            &b"And everywhere that Mary went, ".to_bytes()
+            &Bytes::from(&b"And everywhere that Mary went, "[..])
-                .concat(&b"the lamb was sure to go.".to_bytes()));
+                .concat(&Bytes::from(&b"the lamb was sure to go."[..])));
 
     assert_eq!(a, b);
 }

test/test_seq.rs

@@ -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.rs

@@ -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];
 }