v0.5.2

This type is the counterpart to BufExt::take. It limits how many bytes
some `BufMut` can actually be filled with.

.travis.yml

@@ -1,17 +0,0 @@
----
-language: rust
-sudo: false
-rust:
-  - nightly
-  - 1.1.0
-
-script:
-  - cargo test
-  - cargo doc --no-deps
-
-after_success:
-  - test $TRAVIS_PULL_REQUEST == "false" && test $TRAVIS_BRANCH == "master" && bash deploy.sh
-
-env:
-  global:
-    secure: "mBLJANLvtmyWCXw4zMquptqHQnws0pF+C/u4zL1Jfwz8T4UnUjmBUMxSOgSEIzrOM3qb+CTCjY2/j6BM21+/Zfdl8k8CvFWtkqQUPwIfrtwddCgI+P8Hlrk8G43drz/8XAbZ7dOl+Ovwhr0xnSD9ImfyXJec1kDWhubmgyt47Fs="

CHANGELOG.md

@@ -0,0 +1,129 @@
+# 0.5.2 (November 27, 2019)
+
+### Added
+- `Limit` methods `into_inner`, `get_ref`, `get_mut`, `limit`, and `set_limit` (#325).
+
+# 0.5.1 (November 25, 2019)
+
+### Fix
+- Growth documentation for `BytesMut` (#321)
+
+# 0.5.0 (November 25, 2019)
+
+### Fix
+- Potential overflow in `copy_to_slice`
+
+### Changed
+- Increased minimum supported Rust version to 1.39.
+- `Bytes` is now a "trait object", allowing for custom allocation strategies (#298)
+- `BytesMut` implicitly grows internal storage. `remaining_mut()` returns
+  `usize::MAX` (#316).
+- `BufMut::bytes_mut` returns `&mut [MaybeUninit<u8>]` to reflect the unknown
+  initialization state (#305).
+- `Buf` / `BufMut` implementations for `&[u8]` and `&mut [u8]`
+  respectively (#261).
+- Move `Buf` / `BufMut` "extra" functions to an extension trait (#306).
+- `BufMutExt::limit` (#309).
+- `Bytes::slice` takes a `RangeBounds` argument (#265).
+- `Bytes::from_static` is now a `const fn` (#311).
+- A multitude of smaller performance optimizations.
+
+### Added
+- `no_std` support (#281).
+- `get_*`, `put_*`, `get_*_le`, and `put_*le` accessors for handling byte order.
+- `BorrowMut` implementation for `BytesMut` (#185).
+
+### Removed
+- `IntoBuf` (#288).
+- `Buf` implementation for `&str` (#301).
+- `byteorder` dependency (#280).
+- `iovec` dependency, use `std::IoSlice` instead (#263).
+- optional `either` dependency (#315).
+- optional `i128` feature -- now available on stable. (#276).
+
+# 0.4.12 (March 6, 2019)
+
+### Added
+- Implement `FromIterator<&'a u8>` for `BytesMut`/`Bytes` (#244).
+- Implement `Buf` for `VecDeque` (#249).
+
+# 0.4.11 (November 17, 2018)
+
+* Use raw pointers for potentially racy loads (#233).
+* Implement `BufRead` for `buf::Reader` (#232).
+* Documentation tweaks (#234).
+
+# 0.4.10 (September 4, 2018)
+
+* impl `Buf` and `BufMut` for `Either` (#225).
+* Add `Bytes::slice_ref` (#208).
+
+# 0.4.9 (July 12, 2018)
+
+* Add 128 bit number support behind a feature flag (#209).
+* Implement `IntoBuf` for `&mut [u8]`
+
+# 0.4.8 (May 25, 2018)
+
+* Fix panic in `BytesMut` `FromIterator` implementation.
+* Bytes: Recycle space when reserving space in vec mode (#197).
+* Bytes: Add resize fn (#203).
+
+# 0.4.7 (April 27, 2018)
+
+* Make `Buf` and `BufMut` usable as trait objects (#186).
+* impl BorrowMut for BytesMut (#185).
+* Improve accessor performance (#195).
+
+# 0.4.6 (Janary 8, 2018)
+
+* Implement FromIterator for Bytes/BytesMut (#148).
+* Add `advance` fn to Bytes/BytesMut (#166).
+* Add `unsplit` fn to `BytesMut` (#162, #173).
+* Improvements to Bytes split fns (#92).
+
+# 0.4.5 (August 12, 2017)
+
+* Fix range bug in `Take::bytes`
+* Misc performance improvements
+* Add extra `PartialEq` implementations.
+* Add `Bytes::with_capacity`
+* Implement `AsMut[u8]` for `BytesMut`
+
+# 0.4.4 (May 26, 2017)
+
+* Add serde support behind feature flag
+* Add `extend_from_slice` on `Bytes` and `BytesMut`
+* Add `truncate` and `clear` on `Bytes`
+* Misc additional std trait implementations
+* Misc performance improvements
+
+# 0.4.3 (April 30, 2017)
+
+* Fix Vec::advance_mut bug
+* Bump minimum Rust version to 1.15
+* Misc performance tweaks
+
+# 0.4.2 (April 5, 2017)
+
+* Misc performance tweaks
+* Improved `Debug` implementation for `Bytes`
+* Avoid some incorrect assert panics
+
+# 0.4.1 (March 15, 2017)
+
+* Expose `buf` module and have most types available from there vs. root.
+* Implement `IntoBuf` for `T: Buf`.
+* Add `FromBuf` and `Buf::collect`.
+* Add iterator adapter for `Buf`.
+* Add scatter/gather support to `Buf` and `BufMut`.
+* Add `Buf::chain`.
+* Reduce allocations on repeated calls to `BytesMut::reserve`.
+* Implement `Debug` for more types.
+* Remove `Source` in favor of `IntoBuf`.
+* Implement `Extend` for `BytesMut`.
+
+
+# 0.4.0 (February 24, 2017)
+
+* Initial release

Cargo.toml

@@ -1,32 +1,29 @@
 [package]
 
-name          = "bytes"
-version       = "0.3.0"
-license       = "MIT"
-authors       = ["Carl Lerche <[email protected]>"]
-description   = "Types and traits for working with bytes"
-documentation = "https://carllerche.github.io/bytes/bytes"
-homepage      = "https://github.com/carllerche/bytes"
-repository    = "https://github.com/carllerche/bytes"
-readme        = "README.md"
-keywords      = ["buffers", "rope", "io"]
-exclude       = [
-    ".gitignore",
-    ".travis.yml",
-    "deploy.sh",
-    "bench/**/*",
-    "test/**/*"
-]
+name = "bytes"
+# When releasing to crates.io:
+# - Update html_root_url.
+# - Update CHANGELOG.md.
+# - Update doc URL.
+# - Create "v0.5.x" git tag.
+version = "0.5.2"
+license = "MIT"
+authors = ["Carl Lerche <[email protected]>"]
+description = "Types and traits for working with bytes"
+documentation = "https://docs.rs/bytes"
+repository = "https://github.com/tokio-rs/bytes"
+readme = "README.md"
+keywords = ["buffers", "zero-copy", "io"]
+categories = ["network-programming", "data-structures"]
+edition = "2018"
+
+[features]
+default = ["std"]
+std = []
+
+[dependencies]
+serde = { version = "1.0", optional = true }
 
 [dev-dependencies]
-rand = "0.3.5"
-
-[[bench]]
-
-name = "bench"
-path = "bench/bench.rs"
-
-[[test]]
-
-name = "test"
-path = "test/test.rs"
+loom = "0.2.10"
+serde_test = "1.0"

LICENSE

@@ -1,52 +1,25 @@
-Copyright (c) 2015 Carl Lerche
+Copyright (c) 2018 Carl Lerche
 
-Permission is hereby granted, free of charge, to any person obtaining a copy of
-this software and associated documentation files (the "Software"), to deal in
-the Software without restriction, including without limitation the rights to
-use, copy, modify, merge, publish, distribute, sublicense, and/or sell copies
-of the Software, and to permit persons to whom the Software is furnished to do
-so, subject to the following conditions:
+Permission is hereby granted, free of charge, to any
+person obtaining a copy of this software and associated
+documentation files (the "Software"), to deal in the
+Software without restriction, including without
+limitation the rights to use, copy, modify, merge,
+publish, distribute, sublicense, and/or sell copies of
+the Software, and to permit persons to whom the Software
+is furnished to do so, subject to the following
+conditions:
 
-The above copyright notice and this permission notice shall be included in all
-copies or substantial portions of the Software.
+The above copyright notice and this permission notice
+shall be included in all copies or substantial portions
+of the Software.
 
-THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
-IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
-FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
-AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
-LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
-OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
-SOFTWARE.
-
----
-
-Additionally, the Rope implementation is heavily inspired by ByteString found
-in the Google protobuf library. The following applies to this code:
-
-Copyright 2014, Google Inc.  All rights reserved.
-
-Redistribution and use in source and binary forms, with or without
-modification, are permitted provided that the following conditions are
-met:
-
-    * Redistributions of source code must retain the above copyright
-notice, this list of conditions and the following disclaimer.
-    * Redistributions in binary form must reproduce the above
-copyright notice, this list of conditions and the following disclaimer
-in the documentation and/or other materials provided with the
-distribution.
-    * Neither the name of Google Inc. nor the names of its
-contributors may be used to endorse or promote products derived from
-this software without specific prior written permission.
-
-THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
-"AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
-LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
-A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
-OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
-SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
-LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
-DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
-THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
-(INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
-OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF
+ANY KIND, EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED
+TO THE WARRANTIES OF MERCHANTABILITY, FITNESS FOR A
+PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT
+SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY
+CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION
+OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR
+IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER
+DEALINGS IN THE SOFTWARE.

README.md

@@ -2,16 +2,47 @@
 
 A utility library for working with bytes.
 
-[![crates.io](http://meritbadge.herokuapp.com/bytes)](https://crates.io/crates/bytes)
-[![Build Status](https://travis-ci.org/carllerche/bytes.svg?branch=master)](https://travis-ci.org/carllerche/bytes)
+[![Crates.io][crates-badge]][crates-url]
+[![Build Status][azure-badge]][azure-url]
 
-- [API documentation](http://carllerche.github.io/bytes/bytes/index.html)
+[crates-badge]: https://img.shields.io/crates/v/bytes.svg
+[crates-url]: https://crates.io/crates/bytes
+[azure-badge]: https://dev.azure.com/tokio-rs/bytes/_apis/build/status/tokio-rs.bytes?branchName=master
+[azure-url]: https://dev.azure.com/tokio-rs/bytes/_build/latest?definitionId=3&branchName=master
+
+[Documentation](https://docs.rs/bytes)
 
 ## Usage
 
 To use `bytes`, first add this to your `Cargo.toml`:
 
 ```toml
-[dependencies.bytes]
-git = "https://github.com/carllerche/bytes"
+[dependencies]
+bytes = "0.5"
 ```
+
+Next, add this to your crate:
+
+```rust
+use bytes::{Bytes, BytesMut, Buf, BufMut};
+```
+
+## Serde support
+
+Serde support is optional and disabled by default. To enable use the feature `serde`.
+
+```toml
+[dependencies]
+bytes = { version = "0.5", features = ["serde"] }
+```
+
+## License
+
+This project is licensed under the [MIT license](LICENSE).
+
+### Contribution
+
+Unless you explicitly state otherwise, any contribution intentionally submitted
+for inclusion in `bytes` by you, shall be licensed as MIT, without any additional
+terms or conditions.
+

azure-pipelines.yml

@@ -0,0 +1,68 @@
+trigger: ["master"]
+pr: ["master"]
+
+jobs:
+# Check formatting
+# - template: ci/azure-rustfmt.yml
+#   parameters:
+#     name: rustfmt
+
+# Apply clippy lints
+# - template: ci/azure-clippy.yml
+#   parameters:
+#     name: clippy
+
+# This represents the minimum Rust version supported by
+# Bytes. Updating this should be done in a dedicated PR.
+#
+# Tests are not run as tests may require newer versions of
+# rust.
+- template: ci/azure-test-stable.yml
+  parameters:
+    name: minrust
+    rust_version: 1.39.0
+    cmd: check
+
+# Stable
+- template: ci/azure-test-stable.yml
+  parameters:
+    name: stable
+    cross: true
+    features:
+      - serde
+
+# Nightly
+- template: ci/azure-test-stable.yml
+  parameters:
+    name: nightly
+    # Pin nightly to avoid being impacted by breakage
+    rust_version: nightly-2019-09-25
+    benches: true
+
+# Run tests on some extra platforms
+- template: ci/azure-cross-compile.yml
+  parameters:
+    name: cross
+
+# Sanitizers
+- template: ci/azure-tsan.yml
+  parameters:
+    name: tsan
+    rust_version: nightly
+
+# Loom
+- template: ci/azure-loom.yml
+  parameters:
+    name: loom
+    rust_version: stable
+
+
+- template: ci/azure-deploy-docs.yml
+  parameters:
+    dependsOn:
+      # - rustfmt
+      # - clippy
+      - stable
+      - nightly
+      - minrust
+      - cross

bench/bench.rs

@@ -1,34 +0,0 @@
-#![feature(test, core)]
-
-use bytes::ByteBuf;
-use bytes::traits::*;
-use iobuf::{RWIobuf};
-use test::Bencher;
-
-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) {
-    b.iter(|| {
-        let mut buf = ByteBuf::mut_with_capacity(SIZE);
-
-        for _ in 0..SIZE {
-            buf.write_slice(&[0]);
-        }
-    });
-}
-
-#[bench]
-pub fn bench_rw_iobuf_fill_4kb(b: &mut Bencher) {
-    b.iter(|| {
-        let mut buf = RWIobuf::new(SIZE);
-
-        for _ in 0..SIZE {
-            let _ = buf.fill(&[0]);
-        }
-    });
-}

benches/buf.rs

@@ -0,0 +1,187 @@
+#![feature(test)]
+#![deny(warnings, rust_2018_idioms)]
+
+extern crate test;
+
+use test::Bencher;
+use bytes::Buf;
+
+/// Dummy Buf implementation
+struct TestBuf {
+    buf: &'static [u8],
+    readlens: &'static [usize],
+    init_pos: usize,
+    pos: usize,
+    readlen_pos: usize,
+    readlen: usize,
+}
+impl TestBuf {
+    fn new(buf: &'static [u8], readlens: &'static [usize], init_pos: usize) -> TestBuf {
+        let mut buf = TestBuf {
+            buf,
+            readlens,
+            init_pos,
+            pos: 0,
+            readlen_pos: 0,
+            readlen: 0,
+        };
+        buf.reset();
+        buf
+    }
+    fn reset(&mut self) {
+        self.pos = self.init_pos;
+        self.readlen_pos = 0;
+        self.next_readlen();
+    }
+    /// Compute the length of the next read :
+    /// - use the next value specified in readlens (capped by remaining) if any
+    /// - else the remaining
+    fn next_readlen(&mut self) {
+        self.readlen = self.buf.len() - self.pos;
+        if let Some(readlen) = self.readlens.get(self.readlen_pos) {
+            self.readlen = std::cmp::min(self.readlen, *readlen);
+            self.readlen_pos += 1;
+        }
+    }
+}
+impl Buf for TestBuf {
+    fn remaining(&self) -> usize {
+        return self.buf.len() - self.pos;
+    }
+    fn advance(&mut self, cnt: usize) {
+        self.pos += cnt;
+        assert!(self.pos <= self.buf.len());
+        self.next_readlen();
+    }
+    fn bytes(&self) -> &[u8] {
+        if self.readlen == 0 {
+            Default::default()
+        } else {
+            &self.buf[self.pos..self.pos + self.readlen]
+        }
+    }
+}
+
+/// Dummy Buf implementation
+///  version with methods forced to not be inlined (to simulate costly calls)
+struct TestBufC {
+    inner: TestBuf,
+}
+impl TestBufC {
+    fn new(buf: &'static [u8], readlens: &'static [usize], init_pos: usize) -> TestBufC {
+        TestBufC {
+            inner: TestBuf::new(buf, readlens, init_pos),
+        }
+    }
+    fn reset(&mut self) {
+        self.inner.reset()
+    }
+}
+impl Buf for TestBufC {
+    #[inline(never)]
+    fn remaining(&self) -> usize {
+        self.inner.remaining()
+    }
+    #[inline(never)]
+    fn advance(&mut self, cnt: usize) {
+        self.inner.advance(cnt)
+    }
+    #[inline(never)]
+    fn bytes(&self) -> &[u8] {
+        self.inner.bytes()
+    }
+}
+
+macro_rules! bench {
+    ($fname:ident, testbuf $testbuf:ident $readlens:expr, $method:ident $(,$arg:expr)*) => (
+        #[bench]
+        fn $fname(b: &mut Bencher) {
+            let mut bufs = [
+                $testbuf::new(&[1u8; 8+0], $readlens, 0),
+                $testbuf::new(&[1u8; 8+1], $readlens, 1),
+                $testbuf::new(&[1u8; 8+2], $readlens, 2),
+                $testbuf::new(&[1u8; 8+3], $readlens, 3),
+                $testbuf::new(&[1u8; 8+4], $readlens, 4),
+                $testbuf::new(&[1u8; 8+5], $readlens, 5),
+                $testbuf::new(&[1u8; 8+6], $readlens, 6),
+                $testbuf::new(&[1u8; 8+7], $readlens, 7),
+            ];
+            b.iter(|| {
+                for i in 0..8 {
+                    bufs[i].reset();
+                    let buf: &mut dyn Buf =  &mut bufs[i]; // type erasure
+                    test::black_box(buf.$method($($arg,)*));
+                }
+            })
+        }
+    );
+    ($fname:ident, slice, $method:ident $(,$arg:expr)*) => (
+        #[bench]
+        fn $fname(b: &mut Bencher) {
+            // buf must be long enough for one read of 8 bytes starting at pos 7
+            let arr = [1u8; 8+7];
+            b.iter(|| {
+                for i in 0..8 {
+                    let mut buf = &arr[i..];
+                    let buf = &mut buf as &mut dyn Buf; // type erasure
+                    test::black_box(buf.$method($($arg,)*));
+                }
+            })
+        }
+    );
+    ($fname:ident, option) => (
+        #[bench]
+        fn $fname(b: &mut Bencher) {
+            let data = [1u8; 1];
+            b.iter(|| {
+                for _ in 0..8 {
+                    let mut buf = Some(data);
+                    let buf = &mut buf as &mut dyn Buf; // type erasure
+                    test::black_box(buf.get_u8());
+                }
+            })
+        }
+    );
+}
+
+macro_rules! bench_group {
+    ($method:ident $(,$arg:expr)*) => (
+        bench!(slice, slice, $method $(,$arg)*);
+        bench!(tbuf_1,        testbuf TestBuf  &[],  $method $(,$arg)*);
+        bench!(tbuf_1_costly, testbuf TestBufC &[],  $method $(,$arg)*);
+        bench!(tbuf_2,        testbuf TestBuf  &[1], $method $(,$arg)*);
+        bench!(tbuf_2_costly, testbuf TestBufC &[1], $method $(,$arg)*);
+        // bench!(tbuf_onebyone,        testbuf TestBuf  &[1,1,1,1,1,1,1,1], $method $(,$arg)*);
+        // bench!(tbuf_onebyone_costly, testbuf TestBufC &[1,1,1,1,1,1,1,1], $method $(,$arg)*);
+    );
+}
+
+mod get_u8 {
+    use super::*;
+    bench_group!(get_u8);
+    bench!(option, option);
+}
+mod get_u16 {
+    use super::*;
+    bench_group!(get_u16);
+}
+mod get_u32 {
+    use super::*;
+    bench_group!(get_u32);
+}
+mod get_u64 {
+    use super::*;
+    bench_group!(get_u64);
+}
+mod get_f32 {
+    use super::*;
+    bench_group!(get_f32);
+}
+mod get_f64 {
+    use super::*;
+    bench_group!(get_f64);
+}
+mod get_uint24 {
+    use super::*;
+    bench_group!(get_uint, 3);
+}

benches/bytes.rs

@@ -0,0 +1,118 @@
+#![feature(test)]
+#![deny(warnings, rust_2018_idioms)]
+
+extern crate test;
+
+use test::Bencher;
+use bytes::Bytes;
+
+#[bench]
+fn deref_unique(b: &mut Bencher) {
+    let buf = Bytes::from(vec![0; 1024]);
+
+    b.iter(|| {
+        for _ in 0..1024 {
+            test::black_box(&buf[..]);
+        }
+    })
+}
+
+#[bench]
+fn deref_shared(b: &mut Bencher) {
+    let buf = Bytes::from(vec![0; 1024]);
+    let _b2 = buf.clone();
+
+    b.iter(|| {
+        for _ in 0..1024 {
+            test::black_box(&buf[..]);
+        }
+    })
+}
+
+#[bench]
+fn deref_static(b: &mut Bencher) {
+    let buf = Bytes::from_static(b"hello world");
+
+    b.iter(|| {
+        for _ in 0..1024 {
+            test::black_box(&buf[..]);
+        }
+    })
+}
+
+#[bench]
+fn clone_static(b: &mut Bencher) {
+    let bytes = Bytes::from_static("hello world 1234567890 and have a good byte 0987654321".as_bytes());
+
+    b.iter(|| {
+        for _ in 0..1024 {
+            test::black_box(&bytes.clone());
+        }
+    })
+}
+
+#[bench]
+fn clone_shared(b: &mut Bencher) {
+    let bytes = Bytes::from(b"hello world 1234567890 and have a good byte 0987654321".to_vec());
+
+    b.iter(|| {
+        for _ in 0..1024 {
+            test::black_box(&bytes.clone());
+        }
+    })
+}
+
+#[bench]
+fn clone_arc_vec(b: &mut Bencher) {
+    use std::sync::Arc;
+    let bytes = Arc::new(b"hello world 1234567890 and have a good byte 0987654321".to_vec());
+
+    b.iter(|| {
+        for _ in 0..1024 {
+            test::black_box(&bytes.clone());
+        }
+    })
+}
+
+#[bench]
+fn from_long_slice(b: &mut Bencher) {
+    let data = [0u8; 128];
+    b.bytes = data.len() as u64;
+    b.iter(|| {
+        let buf = Bytes::copy_from_slice(&data[..]);
+        test::black_box(buf);
+    })
+}
+
+#[bench]
+fn slice_empty(b: &mut Bencher) {
+    b.iter(|| {
+        let b = Bytes::from(vec![17; 1024]).clone();
+        for i in 0..1000 {
+            test::black_box(b.slice(i % 100..i % 100));
+        }
+    })
+}
+
+#[bench]
+fn slice_short_from_arc(b: &mut Bencher) {
+    b.iter(|| {
+        // `clone` is to convert to ARC
+        let b = Bytes::from(vec![17; 1024]).clone();
+        for i in 0..1000 {
+            test::black_box(b.slice(1..2 + i % 10));
+        }
+    })
+}
+
+#[bench]
+fn split_off_and_drop(b: &mut Bencher) {
+    b.iter(|| {
+        for _ in 0..1024 {
+            let v = vec![10; 200];
+            let mut b = Bytes::from(v);
+            test::black_box(b.split_off(100));
+            test::black_box(b);
+        }
+    })
+}

benches/bytes_mut.rs

@@ -0,0 +1,249 @@
+#![feature(test)]
+#![deny(warnings, rust_2018_idioms)]
+
+extern crate test;
+
+use test::Bencher;
+use bytes::{BufMut, BytesMut};
+
+#[bench]
+fn alloc_small(b: &mut Bencher) {
+    b.iter(|| {
+        for _ in 0..1024 {
+            test::black_box(BytesMut::with_capacity(12));
+        }
+    })
+}
+
+#[bench]
+fn alloc_mid(b: &mut Bencher) {
+    b.iter(|| {
+        test::black_box(BytesMut::with_capacity(128));
+    })
+}
+
+#[bench]
+fn alloc_big(b: &mut Bencher) {
+    b.iter(|| {
+        test::black_box(BytesMut::with_capacity(4096));
+    })
+}
+
+
+#[bench]
+fn deref_unique(b: &mut Bencher) {
+    let mut buf = BytesMut::with_capacity(4096);
+    buf.put(&[0u8; 1024][..]);
+
+    b.iter(|| {
+        for _ in 0..1024 {
+            test::black_box(&buf[..]);
+        }
+    })
+}
+
+#[bench]
+fn deref_unique_unroll(b: &mut Bencher) {
+    let mut buf = BytesMut::with_capacity(4096);
+    buf.put(&[0u8; 1024][..]);
+
+    b.iter(|| {
+        for _ in 0..128 {
+            test::black_box(&buf[..]);
+            test::black_box(&buf[..]);
+            test::black_box(&buf[..]);
+            test::black_box(&buf[..]);
+            test::black_box(&buf[..]);
+            test::black_box(&buf[..]);
+            test::black_box(&buf[..]);
+            test::black_box(&buf[..]);
+        }
+    })
+}
+
+#[bench]
+fn deref_shared(b: &mut Bencher) {
+    let mut buf = BytesMut::with_capacity(4096);
+    buf.put(&[0u8; 1024][..]);
+    let _b2 = buf.split_off(1024);
+
+    b.iter(|| {
+        for _ in 0..1024 {
+            test::black_box(&buf[..]);
+        }
+    })
+}
+
+#[bench]
+fn deref_two(b: &mut Bencher) {
+    let mut buf1 = BytesMut::with_capacity(8);
+    buf1.put(&[0u8; 8][..]);
+
+    let mut buf2 = BytesMut::with_capacity(4096);
+    buf2.put(&[0u8; 1024][..]);
+
+    b.iter(|| {
+        for _ in 0..512 {
+            test::black_box(&buf1[..]);
+            test::black_box(&buf2[..]);
+        }
+    })
+}
+
+#[bench]
+fn clone_frozen(b: &mut Bencher) {
+    let bytes = BytesMut::from(&b"hello world 1234567890 and have a good byte 0987654321"[..]).split().freeze();
+
+    b.iter(|| {
+        for _ in 0..1024 {
+            test::black_box(&bytes.clone());
+        }
+    })
+}
+
+#[bench]
+fn alloc_write_split_to_mid(b: &mut Bencher) {
+    b.iter(|| {
+        let mut buf = BytesMut::with_capacity(128);
+        buf.put_slice(&[0u8; 64]);
+        test::black_box(buf.split_to(64));
+    })
+}
+
+#[bench]
+fn drain_write_drain(b: &mut Bencher) {
+    let data = [0u8; 128];
+
+    b.iter(|| {
+        let mut buf = BytesMut::with_capacity(1024);
+        let mut parts = Vec::with_capacity(8);
+
+        for _ in 0..8 {
+            buf.put(&data[..]);
+            parts.push(buf.split_to(128));
+        }
+
+        test::black_box(parts);
+    })
+}
+
+#[bench]
+fn fmt_write(b: &mut Bencher) {
+    use std::fmt::Write;
+    let mut buf = BytesMut::with_capacity(128);
+    let s = "foo bar baz quux lorem ipsum dolor et";
+
+    b.bytes = s.len() as u64;
+    b.iter(|| {
+        let _ = write!(buf, "{}", s);
+        test::black_box(&buf);
+        unsafe { buf.set_len(0); }
+    })
+}
+
+#[bench]
+fn bytes_mut_extend(b: &mut Bencher) {
+    let mut buf = BytesMut::with_capacity(256);
+    let data = [33u8; 32];
+
+    b.bytes = data.len() as u64 * 4;
+    b.iter(|| {
+        for _ in 0..4 {
+            buf.extend(&data);
+        }
+        test::black_box(&buf);
+        unsafe { buf.set_len(0); }
+    });
+}
+
+// BufMut for BytesMut vs Vec<u8>
+
+#[bench]
+fn put_slice_bytes_mut(b: &mut Bencher) {
+    let mut buf = BytesMut::with_capacity(256);
+    let data = [33u8; 32];
+
+    b.bytes = data.len() as u64 * 4;
+    b.iter(|| {
+        for _ in 0..4 {
+            buf.put_slice(&data);
+        }
+        test::black_box(&buf);
+        unsafe { buf.set_len(0); }
+    });
+}
+
+#[bench]
+fn put_u8_bytes_mut(b: &mut Bencher) {
+    let mut buf = BytesMut::with_capacity(256);
+    let cnt = 128;
+
+    b.bytes = cnt as u64;
+    b.iter(|| {
+        for _ in 0..cnt {
+            buf.put_u8(b'x');
+        }
+        test::black_box(&buf);
+        unsafe { buf.set_len(0); }
+    });
+}
+
+#[bench]
+fn put_slice_vec(b: &mut Bencher) {
+    let mut buf = Vec::<u8>::with_capacity(256);
+    let data = [33u8; 32];
+
+    b.bytes = data.len() as u64 * 4;
+    b.iter(|| {
+        for _ in 0..4 {
+            buf.put_slice(&data);
+        }
+        test::black_box(&buf);
+        unsafe { buf.set_len(0); }
+    });
+}
+
+#[bench]
+fn put_u8_vec(b: &mut Bencher) {
+    let mut buf = Vec::<u8>::with_capacity(256);
+    let cnt = 128;
+
+    b.bytes = cnt as u64;
+    b.iter(|| {
+        for _ in 0..cnt {
+            buf.put_u8(b'x');
+        }
+        test::black_box(&buf);
+        unsafe { buf.set_len(0); }
+    });
+}
+
+#[bench]
+fn put_slice_vec_extend(b: &mut Bencher) {
+    let mut buf = Vec::<u8>::with_capacity(256);
+    let data = [33u8; 32];
+
+    b.bytes = data.len() as u64 * 4;
+    b.iter(|| {
+        for _ in 0..4 {
+            buf.extend_from_slice(&data);
+        }
+        test::black_box(&buf);
+        unsafe { buf.set_len(0); }
+    });
+}
+
+#[bench]
+fn put_u8_vec_push(b: &mut Bencher) {
+    let mut buf = Vec::<u8>::with_capacity(256);
+    let cnt = 128;
+
+    b.bytes = cnt as u64;
+    b.iter(|| {
+        for _ in 0..cnt {
+            buf.push(b'x');
+        }
+        test::black_box(&buf);
+        unsafe { buf.set_len(0); }
+    });
+}

ci/azure-cross-compile.yml

@@ -0,0 +1,46 @@
+parameters:
+  cmd: build
+  rust_version: stable
+
+jobs:
+- job: ${{ parameters.name }}
+  displayName: Cross
+  strategy:
+    matrix:
+      i686:
+        vmImage: ubuntu-16.04
+        target: i686-unknown-linux-gnu
+      armv7:
+        vmImage: ubuntu-16.04
+        target: armv7-unknown-linux-gnueabihf
+      powerpc:
+        vmImage: ubuntu-16.04
+        target: powerpc-unknown-linux-gnu
+      powerpc64:
+        vmImage: ubuntu-16.04
+        target: powerpc64-unknown-linux-gnu
+      wasm:
+        vmImage: ubuntu-16.04
+        target: wasm32-unknown-unknown
+  pool:
+    vmImage: $(vmImage)
+
+  steps:
+    - template: azure-install-rust.yml
+      parameters:
+        rust_version: ${{parameters.rust_version}}
+
+    - script: cargo install cross
+      displayName: Install cross
+      condition: not(eq(variables['target'], 'wasm32-unknown-unknown'))
+
+    - script: cross ${{ parameters.cmd }} --target $(target)
+      displayName: cross ${{ parameters.cmd }} --target $(target)
+      condition: not(eq(variables['target'], 'wasm32-unknown-unknown'))
+
+    # WASM support
+    - script: |
+        rustup target add $(target)
+        cargo build --target $(target)
+      displayName: cargo build --target $(target)
+      condition: eq(variables['target'], 'wasm32-unknown-unknown')

ci/azure-deploy-docs.yml

@@ -0,0 +1,39 @@
+parameters:
+  dependsOn: []
+
+jobs:
+- job: documentation
+  displayName: 'Deploy API Documentation'
+  condition: and(succeeded(), eq(variables['Build.SourceBranch'], 'refs/heads/master'))
+  pool:
+    vmImage: 'Ubuntu 16.04'
+  dependsOn:
+    - ${{ parameters.dependsOn }}
+  steps:
+  - template: azure-install-rust.yml
+    parameters:
+      rust_version: stable
+  - script: |
+      cargo doc --no-deps
+      cp -R target/doc '$(Build.BinariesDirectory)'
+    displayName: 'Generate Documentation'
+  - script: |
+      set -e
+
+      git --version
+      ls -la
+      git init
+      git config user.name 'Deployment Bot (from Azure Pipelines)'
+      git config user.email '[email protected]'
+      git config --global credential.helper 'store --file ~/.my-credentials'
+      printf "protocol=https\nhost=github.com\nusername=carllerche\npassword=%s\n\n" "$GITHUB_TOKEN" | git credential-store --file ~/.my-credentials store
+      git remote add origin https://github.com/tokio-rs/bytes
+      git checkout -b gh-pages
+      git add .
+      git commit -m 'Deploy Bytes API documentation'
+      git push -f origin gh-pages
+    env:
+      GITHUB_TOKEN: $(githubPersonalToken)
+    workingDirectory: '$(Build.BinariesDirectory)'
+    displayName: 'Deploy Documentation'
+

ci/azure-install-rust.yml

@@ -0,0 +1,33 @@
+steps:
+  # Linux and macOS.
+  - script: |
+      set -e
+      curl https://sh.rustup.rs -sSf | sh -s -- -y --default-toolchain none
+      export PATH=$PATH:$HOME/.cargo/bin
+      rustup toolchain install $RUSTUP_TOOLCHAIN
+      rustup default $RUSTUP_TOOLCHAIN
+      echo "##vso[task.setvariable variable=PATH;]$PATH:$HOME/.cargo/bin"
+    env:
+      RUSTUP_TOOLCHAIN: ${{parameters.rust_version}}
+    displayName: "Install rust (*nix)"
+    condition: not(eq(variables['Agent.OS'], 'Windows_NT'))
+
+  # Windows.
+  - script: |
+      curl -sSf -o rustup-init.exe https://win.rustup.rs
+      rustup-init.exe -y --default-toolchain none
+      set PATH=%PATH%;%USERPROFILE%\.cargo\bin
+      rustup toolchain install %RUSTUP_TOOLCHAIN%
+      rustup default %RUSTUP_TOOLCHAIN%
+      echo "##vso[task.setvariable variable=PATH;]%PATH%;%USERPROFILE%\.cargo\bin"
+    env:
+      RUSTUP_TOOLCHAIN: ${{parameters.rust_version}}
+    displayName: "Install rust (windows)"
+    condition: eq(variables['Agent.OS'], 'Windows_NT')
+
+  # All platforms.
+  - script: |
+        rustup toolchain list
+        rustc -Vv
+        cargo -V
+    displayName: Query rust and cargo versions

ci/azure-loom.yml

@@ -0,0 +1,15 @@
+jobs:
+- job: ${{parameters.name}}
+  displayName: Loom tests
+  pool:
+    vmImage: ubuntu-16.04
+
+  steps:
+  - template: azure-install-rust.yml
+    parameters:
+      rust_version: ${{parameters.rust_version}}
+
+  - script: RUSTFLAGS="--cfg loom" cargo test --lib
+    displayName: RUSTFLAGS="--cfg loom" cargo test --lib
+
+

ci/azure-test-stable.yml

@@ -0,0 +1,50 @@
+parameters:
+  cmd: test
+  rust_version: stable
+  features: []
+
+jobs:
+- job: ${{ parameters.name }}
+  displayName: ${{ parameters.displayName }}
+  strategy:
+    matrix:
+      Linux:
+        vmImage: ubuntu-16.04
+
+      ${{ if parameters.cross }}:
+        MacOS:
+          vmImage: macOS-10.13
+        Windows:
+          vmImage: vs2017-win2016
+  pool:
+    vmImage: $(vmImage)
+
+  steps:
+  - template: azure-install-rust.yml
+    parameters:
+      rust_version: ${{parameters.rust_version}}
+
+  # Run with default crate features
+  - script: cargo ${{ parameters.cmd }}
+    displayName: cargo ${{ parameters.cmd }}
+
+  # Run with each specified feature
+  - ${{ each feature in parameters.features }}:
+    - script: cargo ${{ parameters.cmd }} --features ${{ feature }}
+      displayName: cargo ${{ parameters.cmd }} --features ${{ feature }}
+
+  - ${{ if eq(parameters.cmd, 'test') }}:
+    - script: cargo doc --no-deps
+      displayName: cargo doc --no-deps
+
+  - ${{ if parameters.benches }}:
+    - script: cargo check --benches
+      displayName: Check benchmarks
+
+  # Run with all features
+  - script: cargo ${{ parameters.cmd }} --all-features
+    displayName: cargo ${{ parameters.cmd }} --all-features
+
+  # Run with no default features
+  - script: cargo check --no-default-features
+    displayName: cargo check --no-default-features

ci/azure-tsan.yml

@@ -0,0 +1,26 @@
+jobs:
+- job: ${{ parameters.name }}
+  displayName: TSAN
+  pool:
+    vmImage: ubuntu-16.04
+
+  steps:
+  - template: azure-install-rust.yml
+    parameters:
+      rust_version: ${{ parameters.rust_version }}
+
+  - script: |
+      set -e
+
+      export RUST_TEST_THREADS=1
+      export ASAN_OPTIONS="detect_odr_violation=0 detect_leaks=0"
+      export TSAN_OPTIONS="suppressions=`pwd`/ci/tsan"
+
+      # Run address sanitizer
+      RUSTFLAGS="-Z sanitizer=address" \
+      cargo test --target x86_64-unknown-linux-gnu --test test_bytes --test test_buf --test test_buf_mut
+
+      # Run thread sanitizer
+      RUSTFLAGS="-Z sanitizer=thread" \
+      cargo test --target x86_64-unknown-linux-gnu --test test_bytes --test test_buf --test test_buf_mut
+    displayName: TSAN / MSAN

ci/tsan

@@ -0,0 +1,24 @@
+# TSAN suppressions file for `bytes`
+
+# TSAN does not understand fences and `Arc::drop` is implemented using a fence.
+# This causes many false positives.
+race:Arc*drop
+race:arc*Weak*drop
+
+# `std` mpsc is not used in any Bytes code base. This race is triggered by some
+# rust runtime logic.
+race:std*mpsc_queue
+
+# Some test runtime races. Allocation should be race free
+race:alloc::alloc
+
+# Not sure why this is warning, but it is in the test harness and not the library.
+race:TestEvent*clone
+race:test::run_tests_console::*closure
+
+# Probably more fences in std.
+race:__call_tls_dtors
+
+# This ignores a false positive caused by `thread::park()`/`thread::unpark()`.
+# See: https://github.com/rust-lang/rust/pull/54806#issuecomment-436193353
+race:pthread_cond_destroy

deploy.sh

@@ -1,18 +0,0 @@
-#!/bin/bash
-
-rev=$(git rev-parse --short HEAD)
-
-cd target/doc
-
-git init
-git config user.name "Carl Lerche"
-git config user.email "[email protected]"
-
-git remote add upstream "https://$GH_TOKEN@github.com/carllerche/bytes"
-git fetch upstream && git reset upstream/gh-pages
-
-touch .
-
-git add -A .
-git commit -m "rebuild pages at ${rev}"
-git push -q upstream HEAD:gh-pages

src/alloc/heap.rs

@@ -1,52 +0,0 @@
-use alloc::{Allocator, Mem, MemRef};
-use std::{mem, ptr, usize};
-use std::ops::DerefMut;
-
-const MAX_ALLOC_SIZE: usize = usize::MAX;
-
-pub struct Heap;
-
-impl Heap {
-    pub fn allocate(&self, len: usize) -> MemRef {
-        // Make sure that the allocation is within the permitted range
-        if len > MAX_ALLOC_SIZE {
-            return MemRef::none();
-        }
-
-        let alloc_len = len +
-            mem::size_of::<Mem>() +
-            mem::size_of::<Vec<u8>>();
-
-        unsafe {
-            let mut vec: Vec<u8> = Vec::with_capacity(alloc_len);
-            vec.set_len(alloc_len);
-
-            let ptr = vec.deref_mut().as_mut_ptr();
-
-            ptr::write(ptr as *mut Vec<u8>, vec);
-
-            let ptr = ptr.offset(mem::size_of::<Vec<u8>>() as isize);
-            ptr::write(ptr as *mut Mem, Mem::new(len, mem::transmute(self as &Allocator)));
-
-            // Return the info
-            MemRef::new(ptr as *mut Mem)
-        }
-    }
-
-    pub fn deallocate(&self, mem: *mut Mem) {
-        unsafe {
-            let ptr = mem as *mut u8;
-            let _ = ptr::read(ptr.offset(-(mem::size_of::<Vec<u8>>() as isize)) as *const Vec<u8>);
-        }
-    }
-}
-
-impl Allocator for Heap {
-    fn allocate(&self, len: usize) -> MemRef {
-        Heap::allocate(self, len)
-    }
-
-    fn deallocate(&self, mem: *mut Mem) {
-        Heap::deallocate(self, mem)
-    }
-}

src/alloc/mod.rs

@@ -1,131 +0,0 @@
-mod heap;
-
-pub use self::heap::{Heap};
-
-use std::{mem, ptr};
-use std::sync::atomic::{AtomicUsize, Ordering};
-
-pub fn heap(len: usize) -> MemRef {
-    Heap.allocate(len)
-}
-
-/// Allocates memory to be used by Bufs or Bytes. Allows allocating memory
-/// using alternate stratgies than the default Rust heap allocator. Also does
-/// not require that allocations are continuous in memory.
-///
-/// For example, an alternate allocator could use a slab of 4kb chunks of
-/// memory and return as many chunks as needed to satisfy the length
-/// requirement.
-pub trait Allocator: Sync + Send {
-
-  /// Allocate memory. May or may not be contiguous.
-  fn allocate(&self, len: usize) -> MemRef;
-
-  /// Deallocate a chunk of memory
-  fn deallocate(&self, mem: *mut Mem);
-}
-
-pub struct MemRef {
-    ptr: *mut u8,
-}
-
-impl MemRef {
-    pub fn new(mem: *mut Mem) -> MemRef {
-        let ptr = mem as *mut u8;
-
-        unsafe {
-            MemRef {
-                ptr: ptr.offset(mem::size_of::<Mem>() as isize),
-            }
-        }
-    }
-
-    #[inline]
-    pub fn none() -> MemRef {
-        MemRef { ptr: ptr::null_mut() }
-    }
-
-    #[inline]
-    pub fn is_none(&self) -> bool {
-        self.ptr.is_null()
-    }
-
-    #[inline]
-    pub fn ptr(&self) -> *mut u8 {
-        self.ptr
-    }
-
-    pub fn bytes(&self) -> &[u8] {
-        use std::slice;
-        unsafe {
-            slice::from_raw_parts(self.ptr(), self.mem().len)
-        }
-    }
-
-    #[inline]
-    pub fn bytes_mut(&mut self) -> &mut [u8] {
-        use std::slice;
-        unsafe {
-            slice::from_raw_parts_mut(self.ptr(), self.mem().len)
-        }
-    }
-
-    #[inline]
-    fn mem_ptr(&self) -> *mut Mem {
-        unsafe {
-            self.ptr.offset(-(mem::size_of::<Mem>() as isize)) as *mut Mem
-        }
-    }
-
-    #[inline]
-    fn mem(&self) -> &Mem {
-        unsafe {
-            mem::transmute(self.mem_ptr())
-        }
-    }
-}
-
-impl Clone for MemRef {
-    #[inline]
-    fn clone(&self) -> MemRef {
-        self.mem().refs.fetch_add(1, Ordering::Relaxed);
-        MemRef { ptr: self.ptr }
-    }
-}
-
-impl Drop for MemRef {
-    fn drop(&mut self) {
-        // Guard against the ref having already been dropped
-        if self.ptr.is_null() { return; }
-
-        // Decrement the ref count
-        if 1 == self.mem().refs.fetch_sub(1, Ordering::Relaxed) {
-            // Last ref dropped, free the memory
-            unsafe {
-                let alloc: &Allocator = mem::transmute(self.mem().allocator);
-                alloc.deallocate(self.mem_ptr());
-            }
-        }
-    }
-}
-
-unsafe impl Send for MemRef { }
-unsafe impl Sync for MemRef { }
-
-/// Memory allocated by an Allocator must be prefixed with Mem
-pub struct Mem {
-    // TODO: It should be possible to reduce the size of this struct
-    allocator: *const Allocator,
-    refs: AtomicUsize,
-    len: usize,
-}
-
-impl Mem {
-    pub fn new(len: usize, allocator: *const Allocator) -> Mem {
-        Mem {
-            allocator: allocator,
-            refs: AtomicUsize::new(1),
-            len: len,
-        }
-    }
-}

src/buf/buf_impl.rs

@@ -0,0 +1,930 @@
+use core::{cmp, ptr, mem};
+
+#[cfg(feature = "std")]
+use std::io::IoSlice;
+
+use alloc::{boxed::Box};
+
+macro_rules! buf_get_impl {
+    ($this:ident, $typ:tt::$conv:tt) => ({
+        const SIZE: usize = mem::size_of::<$typ>();
+         // try to convert directly from the bytes
+         // this Option<ret> trick is to avoid keeping a borrow on self
+         // when advance() is called (mut borrow) and to call bytes() only once
+        let ret =  $this.bytes().get(..SIZE).map(|src| unsafe {
+            $typ::$conv(*(src as *const _ as *const [_; SIZE]))
+        });
+
+        if let Some(ret) = ret {
+             // if the direct conversion was possible, advance and return
+            $this.advance(SIZE);
+            return ret;
+        } else {
+            // if not we copy the bytes in a temp buffer then convert
+            let mut buf = [0; SIZE];
+            $this.copy_to_slice(&mut buf); // (do the advance)
+            return $typ::$conv(buf);
+        }
+    });
+    (le => $this:ident, $typ:tt, $len_to_read:expr) => ({
+        debug_assert!(mem::size_of::<$typ>() >= $len_to_read);
+
+        // The same trick as above does not improve the best case speed.
+        // It seems to be linked to the way the method is optimised by the compiler
+        let mut buf = [0; (mem::size_of::<$typ>())];
+        $this.copy_to_slice(&mut buf[..($len_to_read)]);
+        return $typ::from_le_bytes(buf);
+    });
+    (be => $this:ident, $typ:tt, $len_to_read:expr) => {{
+        debug_assert!(mem::size_of::<$typ>() >= $len_to_read);
+
+        let mut buf = [0; (mem::size_of::<$typ>())];
+        $this.copy_to_slice(&mut buf[mem::size_of::<$typ>()-($len_to_read)..]);
+        return $typ::from_be_bytes(buf);
+    }};
+}
+
+/// Read bytes from a buffer.
+///
+/// A buffer stores bytes in memory such that read operations are infallible.
+/// The underlying storage may or may not be in contiguous memory. A `Buf` value
+/// is a cursor into the buffer. Reading from `Buf` advances the cursor
+/// position. It can be thought of as an efficient `Iterator` for collections of
+/// bytes.
+///
+/// The simplest `Buf` is a `&[u8]`.
+///
+/// ```
+/// use bytes::Buf;
+///
+/// let mut buf = &b"hello world"[..];
+///
+/// assert_eq!(b'h', buf.get_u8());
+/// assert_eq!(b'e', buf.get_u8());
+/// assert_eq!(b'l', buf.get_u8());
+///
+/// let mut rest = [0; 8];
+/// buf.copy_to_slice(&mut rest);
+///
+/// assert_eq!(&rest[..], &b"lo world"[..]);
+/// ```
+pub trait Buf {
+    /// Returns the number of bytes between the current position and the end of
+    /// the buffer.
+    ///
+    /// This value is greater than or equal to the length of the slice returned
+    /// by `bytes`.
+    ///
+    /// # Examples
+    ///
+    /// ```
+    /// use bytes::Buf;
+    ///
+    /// let mut buf = &b"hello world"[..];
+    ///
+    /// assert_eq!(buf.remaining(), 11);
+    ///
+    /// buf.get_u8();
+    ///
+    /// assert_eq!(buf.remaining(), 10);
+    /// ```
+    ///
+    /// # Implementer notes
+    ///
+    /// Implementations of `remaining` should ensure that the return value does
+    /// not change unless a call is made to `advance` or any other function that
+    /// is documented to change the `Buf`'s current position.
+    fn remaining(&self) -> usize;
+
+    /// Returns a slice starting at the current position and of length between 0
+    /// and `Buf::remaining()`. Note that this *can* return shorter slice (this allows
+    /// non-continuous internal representation).
+    ///
+    /// This is a lower level function. Most operations are done with other
+    /// functions.
+    ///
+    /// # Examples
+    ///
+    /// ```
+    /// use bytes::Buf;
+    ///
+    /// let mut buf = &b"hello world"[..];
+    ///
+    /// assert_eq!(buf.bytes(), &b"hello world"[..]);
+    ///
+    /// buf.advance(6);
+    ///
+    /// assert_eq!(buf.bytes(), &b"world"[..]);
+    /// ```
+    ///
+    /// # Implementer notes
+    ///
+    /// This function should never panic. Once the end of the buffer is reached,
+    /// i.e., `Buf::remaining` returns 0, calls to `bytes` should return an
+    /// empty slice.
+    fn bytes(&self) -> &[u8];
+
+    /// Fills `dst` with potentially multiple slices starting at `self`'s
+    /// current position.
+    ///
+    /// If the `Buf` is backed by disjoint slices of bytes, `bytes_vectored` enables
+    /// fetching more than one slice at once. `dst` is a slice of `IoSlice`
+    /// references, enabling the slice to be directly used with [`writev`]
+    /// without any further conversion. The sum of the lengths of all the
+    /// buffers in `dst` will be less than or equal to `Buf::remaining()`.
+    ///
+    /// The entries in `dst` will be overwritten, but the data **contained** by
+    /// the slices **will not** be modified. If `bytes_vectored` does not fill every
+    /// entry in `dst`, then `dst` is guaranteed to contain all remaining slices
+    /// in `self.
+    ///
+    /// This is a lower level function. Most operations are done with other
+    /// functions.
+    ///
+    /// # Implementer notes
+    ///
+    /// This function should never panic. Once the end of the buffer is reached,
+    /// i.e., `Buf::remaining` returns 0, calls to `bytes_vectored` must return 0
+    /// without mutating `dst`.
+    ///
+    /// Implementations should also take care to properly handle being called
+    /// with `dst` being a zero length slice.
+    ///
+    /// [`writev`]: http://man7.org/linux/man-pages/man2/readv.2.html
+    #[cfg(feature = "std")]
+    fn bytes_vectored<'a>(&'a self, dst: &mut [IoSlice<'a>]) -> usize {
+        if dst.is_empty() {
+            return 0;
+        }
+
+        if self.has_remaining() {
+            dst[0] = IoSlice::new(self.bytes());
+            1
+        } else {
+            0
+        }
+    }
+
+    /// Advance the internal cursor of the Buf
+    ///
+    /// The next call to `bytes` will return a slice starting `cnt` bytes
+    /// further into the underlying buffer.
+    ///
+    /// # Examples
+    ///
+    /// ```
+    /// use bytes::Buf;
+    ///
+    /// let mut buf = &b"hello world"[..];
+    ///
+    /// assert_eq!(buf.bytes(), &b"hello world"[..]);
+    ///
+    /// buf.advance(6);
+    ///
+    /// assert_eq!(buf.bytes(), &b"world"[..]);
+    /// ```
+    ///
+    /// # Panics
+    ///
+    /// This function **may** panic if `cnt > self.remaining()`.
+    ///
+    /// # Implementer notes
+    ///
+    /// It is recommended for implementations of `advance` to panic if `cnt >
+    /// self.remaining()`. If the implementation does not panic, the call must
+    /// behave as if `cnt == self.remaining()`.
+    ///
+    /// A call with `cnt == 0` should never panic and be a no-op.
+    fn advance(&mut self, cnt: usize);
+
+    /// Returns true if there are any more bytes to consume
+    ///
+    /// This is equivalent to `self.remaining() != 0`.
+    ///
+    /// # Examples
+    ///
+    /// ```
+    /// use bytes::Buf;
+    ///
+    /// let mut buf = &b"a"[..];
+    ///
+    /// assert!(buf.has_remaining());
+    ///
+    /// buf.get_u8();
+    ///
+    /// assert!(!buf.has_remaining());
+    /// ```
+    fn has_remaining(&self) -> bool {
+        self.remaining() > 0
+    }
+
+    /// Copies bytes from `self` into `dst`.
+    ///
+    /// The cursor is advanced by the number of bytes copied. `self` must have
+    /// enough remaining bytes to fill `dst`.
+    ///
+    /// # Examples
+    ///
+    /// ```
+    /// use bytes::Buf;
+    ///
+    /// let mut buf = &b"hello world"[..];
+    /// let mut dst = [0; 5];
+    ///
+    /// buf.copy_to_slice(&mut dst);
+    /// assert_eq!(&b"hello"[..], &dst);
+    /// assert_eq!(6, buf.remaining());
+    /// ```
+    ///
+    /// # Panics
+    ///
+    /// This function panics if `self.remaining() < dst.len()`
+    fn copy_to_slice(&mut self, dst: &mut [u8]) {
+        let mut off = 0;
+
+        assert!(self.remaining() >= dst.len());
+
+        while off < dst.len() {
+            let cnt;
+
+            unsafe {
+                let src = self.bytes();
+                cnt = cmp::min(src.len(), dst.len() - off);
+
+                ptr::copy_nonoverlapping(
+                    src.as_ptr(), dst[off..].as_mut_ptr(), cnt);
+
+                off += cnt;
+            }
+
+            self.advance(cnt);
+        }
+    }
+
+    /// Gets an unsigned 8 bit integer from `self`.
+    ///
+    /// The current position is advanced by 1.
+    ///
+    /// # Examples
+    ///
+    /// ```
+    /// use bytes::Buf;
+    ///
+    /// let mut buf = &b"\x08 hello"[..];
+    /// assert_eq!(8, buf.get_u8());
+    /// ```
+    ///
+    /// # Panics
+    ///
+    /// This function panics if there is no more remaining data in `self`.
+    fn get_u8(&mut self) -> u8 {
+        assert!(self.remaining() >= 1);
+        let ret = self.bytes()[0];
+        self.advance(1);
+        ret
+    }
+
+    /// Gets a signed 8 bit integer from `self`.
+    ///
+    /// The current position is advanced by 1.
+    ///
+    /// # Examples
+    ///
+    /// ```
+    /// use bytes::Buf;
+    ///
+    /// let mut buf = &b"\x08 hello"[..];
+    /// assert_eq!(8, buf.get_i8());
+    /// ```
+    ///
+    /// # Panics
+    ///
+    /// This function panics if there is no more remaining data in `self`.
+    fn get_i8(&mut self) -> i8 {
+        assert!(self.remaining() >= 1);
+        let ret = self.bytes()[0] as i8;
+        self.advance(1);
+        ret
+    }
+
+    /// Gets an unsigned 16 bit integer from `self` in big-endian byte order.
+    ///
+    /// The current position is advanced by 2.
+    ///
+    /// # Examples
+    ///
+    /// ```
+    /// use bytes::Buf;
+    ///
+    /// let mut buf = &b"\x08\x09 hello"[..];
+    /// assert_eq!(0x0809, buf.get_u16());
+    /// ```
+    ///
+    /// # Panics
+    ///
+    /// This function panics if there is not enough remaining data in `self`.
+    fn get_u16(&mut self) -> u16 {
+        buf_get_impl!(self, u16::from_be_bytes);
+    }
+
+    /// Gets an unsigned 16 bit integer from `self` in little-endian byte order.
+    ///
+    /// The current position is advanced by 2.
+    ///
+    /// # Examples
+    ///
+    /// ```
+    /// use bytes::Buf;
+    ///
+    /// let mut buf = &b"\x09\x08 hello"[..];
+    /// assert_eq!(0x0809, buf.get_u16_le());
+    /// ```
+    ///
+    /// # Panics
+    ///
+    /// This function panics if there is not enough remaining data in `self`.
+    fn get_u16_le(&mut self) -> u16 {
+        buf_get_impl!(self, u16::from_le_bytes);
+    }
+
+    /// Gets a signed 16 bit integer from `self` in big-endian byte order.
+    ///
+    /// The current position is advanced by 2.
+    ///
+    /// # Examples
+    ///
+    /// ```
+    /// use bytes::Buf;
+    ///
+    /// let mut buf = &b"\x08\x09 hello"[..];
+    /// assert_eq!(0x0809, buf.get_i16());
+    /// ```
+    ///
+    /// # Panics
+    ///
+    /// This function panics if there is not enough remaining data in `self`.
+    fn get_i16(&mut self) -> i16 {
+        buf_get_impl!(self, i16::from_be_bytes);
+    }
+
+    /// Gets a signed 16 bit integer from `self` in little-endian byte order.
+    ///
+    /// The current position is advanced by 2.
+    ///
+    /// # Examples
+    ///
+    /// ```
+    /// use bytes::Buf;
+    ///
+    /// let mut buf = &b"\x09\x08 hello"[..];
+    /// assert_eq!(0x0809, buf.get_i16_le());
+    /// ```
+    ///
+    /// # Panics
+    ///
+    /// This function panics if there is not enough remaining data in `self`.
+    fn get_i16_le(&mut self) -> i16 {
+        buf_get_impl!(self, i16::from_le_bytes);
+    }
+
+    /// Gets an unsigned 32 bit integer from `self` in the big-endian byte order.
+    ///
+    /// The current position is advanced by 4.
+    ///
+    /// # Examples
+    ///
+    /// ```
+    /// use bytes::Buf;
+    ///
+    /// let mut buf = &b"\x08\x09\xA0\xA1 hello"[..];
+    /// assert_eq!(0x0809A0A1, buf.get_u32());
+    /// ```
+    ///
+    /// # Panics
+    ///
+    /// This function panics if there is not enough remaining data in `self`.
+    fn get_u32(&mut self) -> u32 {
+        buf_get_impl!(self, u32::from_be_bytes);
+    }
+
+    /// Gets an unsigned 32 bit integer from `self` in the little-endian byte order.
+    ///
+    /// The current position is advanced by 4.
+    ///
+    /// # Examples
+    ///
+    /// ```
+    /// use bytes::Buf;
+    ///
+    /// let mut buf = &b"\xA1\xA0\x09\x08 hello"[..];
+    /// assert_eq!(0x0809A0A1, buf.get_u32_le());
+    /// ```
+    ///
+    /// # Panics
+    ///
+    /// This function panics if there is not enough remaining data in `self`.
+    fn get_u32_le(&mut self) -> u32 {
+        buf_get_impl!(self, u32::from_le_bytes);
+    }
+
+    /// Gets a signed 32 bit integer from `self` in big-endian byte order.
+    ///
+    /// The current position is advanced by 4.
+    ///
+    /// # Examples
+    ///
+    /// ```
+    /// use bytes::Buf;
+    ///
+    /// let mut buf = &b"\x08\x09\xA0\xA1 hello"[..];
+    /// assert_eq!(0x0809A0A1, buf.get_i32());
+    /// ```
+    ///
+    /// # Panics
+    ///
+    /// This function panics if there is not enough remaining data in `self`.
+    fn get_i32(&mut self) -> i32 {
+        buf_get_impl!(self, i32::from_be_bytes);
+    }
+
+    /// Gets a signed 32 bit integer from `self` in little-endian byte order.
+    ///
+    /// The current position is advanced by 4.
+    ///
+    /// # Examples
+    ///
+    /// ```
+    /// use bytes::Buf;
+    ///
+    /// let mut buf = &b"\xA1\xA0\x09\x08 hello"[..];
+    /// assert_eq!(0x0809A0A1, buf.get_i32_le());
+    /// ```
+    ///
+    /// # Panics
+    ///
+    /// This function panics if there is not enough remaining data in `self`.
+    fn get_i32_le(&mut self) -> i32 {
+        buf_get_impl!(self, i32::from_le_bytes);
+    }
+
+    /// Gets an unsigned 64 bit integer from `self` in big-endian byte order.
+    ///
+    /// The current position is advanced by 8.
+    ///
+    /// # Examples
+    ///
+    /// ```
+    /// use bytes::Buf;
+    ///
+    /// let mut buf = &b"\x01\x02\x03\x04\x05\x06\x07\x08 hello"[..];
+    /// assert_eq!(0x0102030405060708, buf.get_u64());
+    /// ```
+    ///
+    /// # Panics
+    ///
+    /// This function panics if there is not enough remaining data in `self`.
+    fn get_u64(&mut self) -> u64 {
+        buf_get_impl!(self, u64::from_be_bytes);
+    }
+
+    /// Gets an unsigned 64 bit integer from `self` in little-endian byte order.
+    ///
+    /// The current position is advanced by 8.
+    ///
+    /// # Examples
+    ///
+    /// ```
+    /// use bytes::Buf;
+    ///
+    /// let mut buf = &b"\x08\x07\x06\x05\x04\x03\x02\x01 hello"[..];
+    /// assert_eq!(0x0102030405060708, buf.get_u64_le());
+    /// ```
+    ///
+    /// # Panics
+    ///
+    /// This function panics if there is not enough remaining data in `self`.
+    fn get_u64_le(&mut self) -> u64 {
+        buf_get_impl!(self, u64::from_le_bytes);
+    }
+
+    /// Gets a signed 64 bit integer from `self` in big-endian byte order.
+    ///
+    /// The current position is advanced by 8.
+    ///
+    /// # Examples
+    ///
+    /// ```
+    /// use bytes::Buf;
+    ///
+    /// let mut buf = &b"\x01\x02\x03\x04\x05\x06\x07\x08 hello"[..];
+    /// assert_eq!(0x0102030405060708, buf.get_i64());
+    /// ```
+    ///
+    /// # Panics
+    ///
+    /// This function panics if there is not enough remaining data in `self`.
+    fn get_i64(&mut self) -> i64 {
+        buf_get_impl!(self, i64::from_be_bytes);
+    }
+
+    /// Gets a signed 64 bit integer from `self` in little-endian byte order.
+    ///
+    /// The current position is advanced by 8.
+    ///
+    /// # Examples
+    ///
+    /// ```
+    /// use bytes::Buf;
+    ///
+    /// let mut buf = &b"\x08\x07\x06\x05\x04\x03\x02\x01 hello"[..];
+    /// assert_eq!(0x0102030405060708, buf.get_i64_le());
+    /// ```
+    ///
+    /// # Panics
+    ///
+    /// This function panics if there is not enough remaining data in `self`.
+    fn get_i64_le(&mut self) -> i64 {
+        buf_get_impl!(self, i64::from_le_bytes);
+    }
+
+    /// Gets an unsigned 128 bit integer from `self` in big-endian byte order.
+    ///
+    /// The current position is advanced by 16.
+    ///
+    /// # Examples
+    ///
+    /// ```
+    /// use bytes::Buf;
+    ///
+    /// let mut buf = &b"\x01\x02\x03\x04\x05\x06\x07\x08\x09\x10\x11\x12\x13\x14\x15\x16 hello"[..];
+    /// assert_eq!(0x01020304050607080910111213141516, buf.get_u128());
+    /// ```
+    ///
+    /// # Panics
+    ///
+    /// This function panics if there is not enough remaining data in `self`.
+    fn get_u128(&mut self) -> u128 {
+        buf_get_impl!(self, u128::from_be_bytes);
+    }
+
+    /// Gets an unsigned 128 bit integer from `self` in little-endian byte order.
+    ///
+    /// The current position is advanced by 16.
+    ///
+    /// # Examples
+    ///
+    /// ```
+    /// use bytes::Buf;
+    ///
+    /// let mut buf = &b"\x16\x15\x14\x13\x12\x11\x10\x09\x08\x07\x06\x05\x04\x03\x02\x01 hello"[..];
+    /// assert_eq!(0x01020304050607080910111213141516, buf.get_u128_le());
+    /// ```
+    ///
+    /// # Panics
+    ///
+    /// This function panics if there is not enough remaining data in `self`.
+    fn get_u128_le(&mut self) -> u128 {
+        buf_get_impl!(self, u128::from_le_bytes);
+    }
+
+    /// Gets a signed 128 bit integer from `self` in big-endian byte order.
+    ///
+    /// The current position is advanced by 16.
+    ///
+    /// # Examples
+    ///
+    /// ```
+    /// use bytes::Buf;
+    ///
+    /// let mut buf = &b"\x01\x02\x03\x04\x05\x06\x07\x08\x09\x10\x11\x12\x13\x14\x15\x16 hello"[..];
+    /// assert_eq!(0x01020304050607080910111213141516, buf.get_i128());
+    /// ```
+    ///
+    /// # Panics
+    ///
+    /// This function panics if there is not enough remaining data in `self`.
+    fn get_i128(&mut self) -> i128 {
+        buf_get_impl!(self, i128::from_be_bytes);
+    }
+
+    /// Gets a signed 128 bit integer from `self` in little-endian byte order.
+    ///
+    /// The current position is advanced by 16.
+    ///
+    /// # Examples
+    ///
+    /// ```
+    /// use bytes::Buf;
+    ///
+    /// let mut buf = &b"\x16\x15\x14\x13\x12\x11\x10\x09\x08\x07\x06\x05\x04\x03\x02\x01 hello"[..];
+    /// assert_eq!(0x01020304050607080910111213141516, buf.get_i128_le());
+    /// ```
+    ///
+    /// # Panics
+    ///
+    /// This function panics if there is not enough remaining data in `self`.
+    fn get_i128_le(&mut self) -> i128 {
+        buf_get_impl!(self, i128::from_le_bytes);
+    }
+
+    /// Gets an unsigned n-byte integer from `self` in big-endian byte order.
+    ///
+    /// The current position is advanced by `nbytes`.
+    ///
+    /// # Examples
+    ///
+    /// ```
+    /// use bytes::Buf;
+    ///
+    /// let mut buf = &b"\x01\x02\x03 hello"[..];
+    /// assert_eq!(0x010203, buf.get_uint(3));
+    /// ```
+    ///
+    /// # Panics
+    ///
+    /// This function panics if there is not enough remaining data in `self`.
+    fn get_uint(&mut self, nbytes: usize) -> u64 {
+        buf_get_impl!(be => self, u64, nbytes);
+    }
+
+    /// Gets an unsigned n-byte integer from `self` in little-endian byte order.
+    ///
+    /// The current position is advanced by `nbytes`.
+    ///
+    /// # Examples
+    ///
+    /// ```
+    /// use bytes::Buf;
+    ///
+    /// let mut buf = &b"\x03\x02\x01 hello"[..];
+    /// assert_eq!(0x010203, buf.get_uint_le(3));
+    /// ```
+    ///
+    /// # Panics
+    ///
+    /// This function panics if there is not enough remaining data in `self`.
+    fn get_uint_le(&mut self, nbytes: usize) -> u64 {
+        buf_get_impl!(le => self, u64, nbytes);
+    }
+
+    /// Gets a signed n-byte integer from `self` in big-endian byte order.
+    ///
+    /// The current position is advanced by `nbytes`.
+    ///
+    /// # Examples
+    ///
+    /// ```
+    /// use bytes::Buf;
+    ///
+    /// let mut buf = &b"\x01\x02\x03 hello"[..];
+    /// assert_eq!(0x010203, buf.get_int(3));
+    /// ```
+    ///
+    /// # Panics
+    ///
+    /// This function panics if there is not enough remaining data in `self`.
+    fn get_int(&mut self, nbytes: usize) -> i64 {
+        buf_get_impl!(be => self, i64, nbytes);
+    }
+
+    /// Gets a signed n-byte integer from `self` in little-endian byte order.
+    ///
+    /// The current position is advanced by `nbytes`.
+    ///
+    /// # Examples
+    ///
+    /// ```
+    /// use bytes::Buf;
+    ///
+    /// let mut buf = &b"\x03\x02\x01 hello"[..];
+    /// assert_eq!(0x010203, buf.get_int_le(3));
+    /// ```
+    ///
+    /// # Panics
+    ///
+    /// This function panics if there is not enough remaining data in `self`.
+    fn get_int_le(&mut self, nbytes: usize) -> i64 {
+        buf_get_impl!(le => self, i64, nbytes);
+    }
+
+    /// Gets an IEEE754 single-precision (4 bytes) floating point number from
+    /// `self` in big-endian byte order.
+    ///
+    /// The current position is advanced by 4.
+    ///
+    /// # Examples
+    ///
+    /// ```
+    /// use bytes::Buf;
+    ///
+    /// let mut buf = &b"\x3F\x99\x99\x9A hello"[..];
+    /// assert_eq!(1.2f32, buf.get_f32());
+    /// ```
+    ///
+    /// # Panics
+    ///
+    /// This function panics if there is not enough remaining data in `self`.
+    fn get_f32(&mut self) -> f32 {
+        f32::from_bits(Self::get_u32(self))
+    }
+
+    /// Gets an IEEE754 single-precision (4 bytes) floating point number from
+    /// `self` in little-endian byte order.
+    ///
+    /// The current position is advanced by 4.
+    ///
+    /// # Examples
+    ///
+    /// ```
+    /// use bytes::Buf;
+    ///
+    /// let mut buf = &b"\x9A\x99\x99\x3F hello"[..];
+    /// assert_eq!(1.2f32, buf.get_f32_le());
+    /// ```
+    ///
+    /// # Panics
+    ///
+    /// This function panics if there is not enough remaining data in `self`.
+    fn get_f32_le(&mut self) -> f32 {
+        f32::from_bits(Self::get_u32_le(self))
+    }
+
+    /// Gets an IEEE754 double-precision (8 bytes) floating point number from
+    /// `self` in big-endian byte order.
+    ///
+    /// The current position is advanced by 8.
+    ///
+    /// # Examples
+    ///
+    /// ```
+    /// use bytes::Buf;
+    ///
+    /// let mut buf = &b"\x3F\xF3\x33\x33\x33\x33\x33\x33 hello"[..];
+    /// assert_eq!(1.2f64, buf.get_f64());
+    /// ```
+    ///
+    /// # Panics
+    ///
+    /// This function panics if there is not enough remaining data in `self`.
+    fn get_f64(&mut self) -> f64 {
+        f64::from_bits(Self::get_u64(self))
+    }
+
+    /// Gets an IEEE754 double-precision (8 bytes) floating point number from
+    /// `self` in little-endian byte order.
+    ///
+    /// The current position is advanced by 8.
+    ///
+    /// # Examples
+    ///
+    /// ```
+    /// use bytes::Buf;
+    ///
+    /// let mut buf = &b"\x33\x33\x33\x33\x33\x33\xF3\x3F hello"[..];
+    /// assert_eq!(1.2f64, buf.get_f64_le());
+    /// ```
+    ///
+    /// # Panics
+    ///
+    /// This function panics if there is not enough remaining data in `self`.
+    fn get_f64_le(&mut self) -> f64 {
+        f64::from_bits(Self::get_u64_le(self))
+    }
+
+    /// Consumes remaining bytes inside self and returns new instance of `Bytes`
+    ///
+    /// # Examples
+    ///
+    /// ```
+    /// use bytes::Buf;
+    ///
+    /// let bytes = (&b"hello world"[..]).to_bytes();
+    /// assert_eq!(&bytes[..], &b"hello world"[..]);
+    /// ```
+    fn to_bytes(&mut self) -> crate::Bytes {
+        use super::BufMut;
+        let mut ret = crate::BytesMut::with_capacity(self.remaining());
+        ret.put(self);
+        ret.freeze()
+    }
+}
+
+impl<T: Buf + ?Sized> Buf for &mut T {
+    fn remaining(&self) -> usize {
+        (**self).remaining()
+    }
+
+    fn bytes(&self) -> &[u8] {
+        (**self).bytes()
+    }
+
+    #[cfg(feature = "std")]
+    fn bytes_vectored<'b>(&'b self, dst: &mut [IoSlice<'b>]) -> usize {
+        (**self).bytes_vectored(dst)
+    }
+
+    fn advance(&mut self, cnt: usize) {
+        (**self).advance(cnt)
+    }
+}
+
+impl<T: Buf + ?Sized> Buf for Box<T> {
+    fn remaining(&self) -> usize {
+        (**self).remaining()
+    }
+
+    fn bytes(&self) -> &[u8] {
+        (**self).bytes()
+    }
+
+    #[cfg(feature = "std")]
+    fn bytes_vectored<'b>(&'b self, dst: &mut [IoSlice<'b>]) -> usize {
+        (**self).bytes_vectored(dst)
+    }
+
+    fn advance(&mut self, cnt: usize) {
+        (**self).advance(cnt)
+    }
+}
+
+impl Buf for &[u8] {
+    #[inline]
+    fn remaining(&self) -> usize {
+        self.len()
+    }
+
+    #[inline]
+    fn bytes(&self) -> &[u8] {
+        self
+    }
+
+    #[inline]
+    fn advance(&mut self, cnt: usize) {
+        *self = &self[cnt..];
+    }
+}
+
+impl Buf for Option<[u8; 1]> {
+    fn remaining(&self) -> usize {
+        if self.is_some() {
+            1
+        } else {
+            0
+        }
+    }
+
+    fn bytes(&self) -> &[u8] {
+        self.as_ref().map(AsRef::as_ref)
+            .unwrap_or(Default::default())
+    }
+
+    fn advance(&mut self, cnt: usize) {
+        if cnt == 0 {
+            return;
+        }
+
+        if self.is_none() {
+            panic!("overflow");
+        } else {
+            assert_eq!(1, cnt);
+            *self = None;
+        }
+    }
+}
+
+#[cfg(feature = "std")]
+impl<T: AsRef<[u8]>> Buf for std::io::Cursor<T> {
+    fn remaining(&self) -> usize {
+        let len = self.get_ref().as_ref().len();
+        let pos = self.position();
+
+        if pos >= len as u64 {
+            return 0;
+        }
+
+        len - pos as usize
+    }
+
+    fn bytes(&self) -> &[u8] {
+        let len = self.get_ref().as_ref().len();
+        let pos = self.position();
+
+        if pos >= len as u64 {
+            return &[];
+        }
+
+        &self.get_ref().as_ref()[pos as usize..]
+    }
+
+    fn advance(&mut self, cnt: usize) {
+        let pos = (self.position() as usize)
+            .checked_add(cnt).expect("overflow");
+
+        assert!(pos <= self.get_ref().as_ref().len());
+        self.set_position(pos as u64);
+    }
+}
+
+// The existence of this function makes the compiler catch if the Buf
+// trait is "object-safe" or not.
+fn _assert_trait_object(_b: &dyn Buf) {}

src/buf/byte.rs

@@ -1,347 +0,0 @@
-use {alloc, Bytes, SeqByteStr, MAX_CAPACITY};
-use traits::{Buf, MutBuf, MutBufExt, ByteStr};
-use std::{cmp, fmt, ptr};
-
-/*
- *
- * ===== ByteBuf =====
- *
- */
-
-/// A `Buf` backed by a contiguous region of memory.
-///
-/// This `Buf` is better suited for cases where there is a clear delineation
-/// between reading and writing.
-pub struct ByteBuf {
-    mem: alloc::MemRef,
-    cap: u32,
-    pos: u32,
-    lim: u32,
-    mark: Option<u32>,
-}
-
-impl ByteBuf {
-    /// Create a new `ByteBuf` by copying the contents of the given slice.
-    pub fn from_slice(bytes: &[u8]) -> ByteBuf {
-        let mut buf = ByteBuf::mut_with_capacity(bytes.len());
-        buf.write(bytes).ok().expect("unexpected failure");
-        buf.flip()
-    }
-
-    pub fn mut_with_capacity(capacity: usize) -> MutByteBuf {
-        assert!(capacity <= MAX_CAPACITY);
-        MutByteBuf { buf: ByteBuf::new(capacity as u32) }
-    }
-
-    pub fn none() -> ByteBuf {
-        ByteBuf {
-            mem: alloc::MemRef::none(),
-            cap: 0,
-            pos: 0,
-            lim: 0,
-            mark: None,
-        }
-    }
-
-    pub unsafe fn from_mem_ref(mem: alloc::MemRef, cap: u32, pos: u32, lim: u32) -> ByteBuf {
-        debug_assert!(pos <= lim && lim <= cap, "invalid arguments; cap={}; pos={}; lim={}", cap, pos, lim);
-
-        ByteBuf {
-            mem: mem,
-            cap: cap,
-            pos: pos,
-            lim: lim,
-            mark: None,
-        }
-    }
-
-    fn new(mut capacity: u32) -> ByteBuf {
-        // Handle 0 capacity case
-        if capacity == 0 {
-            return ByteBuf::none();
-        }
-
-        // Round the capacity to the closest power of 2
-        capacity = capacity.next_power_of_two();
-
-        // Allocate the memory
-        let mem = alloc::heap(capacity as usize);
-
-        // If the allocation failed, return a blank buf
-        if mem.is_none() {
-            return ByteBuf::none();
-        }
-
-        ByteBuf {
-            mem: mem,
-            cap: capacity,
-            pos: 0,
-            lim: capacity,
-            mark: None,
-        }
-    }
-
-    pub fn capacity(&self) -> usize {
-        self.cap as usize
-    }
-
-    pub fn flip(self) -> MutByteBuf {
-        let mut buf = MutByteBuf { buf: self };
-        buf.clear();
-        buf
-    }
-
-    /// Flips the buffer back to mutable, resetting the write position
-    /// to the byte after the previous write.
-    pub fn resume(mut self) -> MutByteBuf {
-        self.pos = self.lim;
-        self.lim = self.cap;
-        MutByteBuf { buf: self }
-    }
-
-    pub fn read_slice(&mut self, dst: &mut [u8]) -> usize {
-        let len = cmp::min(dst.len(), self.remaining());
-        let cnt = len as u32;
-
-        unsafe {
-            ptr::copy_nonoverlapping(
-                self.mem.ptr().offset(self.pos as isize),
-                dst.as_mut_ptr(),
-                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.
-    ///
-    /// Together with `reset`, this can be used to read from a section of the
-    /// buffer multiple times. The marked location will be cleared when the
-    /// buffer is flipped.
-    pub fn mark(&mut self) {
-        self.mark = Some(self.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.pos = self.mark.take().expect("no mark set");
-    }
-
-    #[inline]
-    fn pos(&self) -> usize {
-        self.pos as usize
-    }
-
-    #[inline]
-    fn lim(&self) -> usize {
-        self.lim as usize
-    }
-
-    #[inline]
-    fn remaining_u32(&self) -> u32 {
-        self.lim - self.pos
-    }
-}
-
-impl Buf for ByteBuf {
-
-    #[inline]
-    fn remaining(&self) -> usize {
-        self.remaining_u32() as usize
-    }
-
-    #[inline]
-    fn bytes<'a>(&'a self) -> &'a [u8] {
-        &self.mem.bytes()[self.pos()..self.lim()]
-    }
-
-    #[inline]
-    fn advance(&mut self, mut cnt: usize) {
-        cnt = cmp::min(cnt, self.remaining());
-        self.pos += cnt as u32;
-    }
-
-    #[inline]
-    fn read_slice(&mut self, dst: &mut [u8]) -> usize {
-        ByteBuf::read_slice(self, dst)
-    }
-}
-
-impl fmt::Debug for ByteBuf {
-    fn fmt(&self, fmt: &mut fmt::Formatter) -> fmt::Result {
-        self.bytes().fmt(fmt)
-    }
-}
-
-/*
- *
- * ===== ROByteBuf =====
- *
- */
-
-/// Same as `ByteBuf` but cannot be flipped to a `MutByteBuf`.
-pub struct ROByteBuf {
-    buf: ByteBuf,
-}
-
-impl ROByteBuf {
-    pub unsafe fn from_mem_ref(mem: alloc::MemRef, cap: u32, pos: u32, lim: u32) -> ROByteBuf {
-        ROByteBuf {
-            buf: ByteBuf::from_mem_ref(mem, cap, pos, lim)
-        }
-    }
-
-    pub fn to_seq_byte_str(self) -> SeqByteStr {
-        self.buf.to_seq_byte_str()
-    }
-
-    pub fn to_bytes(self) -> Bytes {
-        self.buf.to_bytes()
-    }
-
-    /// Marks the current read location.
-    ///
-    /// Together with `reset`, this can be used to read from a section of the
-    /// buffer multiple times.
-    pub fn mark(&mut self) {
-        self.buf.mark = Some(self.buf.pos);
-    }
-
-    /// Resets the read position to the previously marked position.
-    ///
-    /// Together with `mark`, this can be used to read from a section of the
-    /// buffer multiple times.
-    ///
-    /// # Panics
-    ///
-    /// This method will panic if no mark has been set.
-    pub fn reset(&mut self) {
-        self.buf.pos = self.buf.mark.take().expect("no mark set");
-    }
-}
-
-impl Buf for ROByteBuf {
-
-    fn remaining(&self) -> usize {
-        self.buf.remaining()
-    }
-
-    fn bytes<'a>(&'a self) -> &'a [u8] {
-        self.buf.bytes()
-    }
-
-    fn advance(&mut self, cnt: usize) {
-        self.buf.advance(cnt)
-    }
-
-    fn read_slice(&mut self, dst: &mut [u8]) -> usize {
-        self.buf.read_slice(dst)
-    }
-}
-
-impl fmt::Debug for ROByteBuf {
-    fn fmt(&self, fmt: &mut fmt::Formatter) -> fmt::Result {
-        self.bytes().fmt(fmt)
-    }
-}
-
-/*
- *
- * ===== MutByteBuf =====
- *
- */
-
-pub struct MutByteBuf {
-    buf: ByteBuf,
-}
-
-impl MutByteBuf {
-    pub fn capacity(&self) -> usize {
-        self.buf.capacity() as usize
-    }
-
-    pub fn flip(self) -> ByteBuf {
-        let mut buf = self.buf;
-
-        buf.lim = buf.pos;
-        buf.pos = 0;
-        buf
-    }
-
-    pub fn clear(&mut self) {
-        self.buf.pos = 0;
-        self.buf.lim = self.buf.cap;
-    }
-
-    #[inline]
-    pub fn write_slice(&mut self, src: &[u8]) -> usize {
-        let cnt = src.len() as u32;
-        let rem = self.buf.remaining_u32();
-
-        if rem < cnt {
-            self.write_ptr(src.as_ptr(), rem)
-        } else {
-            self.write_ptr(src.as_ptr(), cnt)
-        }
-    }
-
-    #[inline]
-    fn write_ptr(&mut self, src: *const u8, len: u32) -> usize {
-        unsafe {
-            ptr::copy_nonoverlapping(
-                src,
-                self.buf.mem.ptr().offset(self.buf.pos as isize),
-                len as usize);
-
-            self.buf.pos += len;
-            len as usize
-        }
-    }
-
-    pub fn bytes<'a>(&'a self) -> &'a [u8] {
-        &self.buf.mem.bytes()[..self.buf.pos()]
-    }
-}
-
-impl MutBuf for MutByteBuf {
-    fn remaining(&self) -> usize {
-        self.buf.remaining()
-    }
-
-    unsafe fn advance(&mut self, cnt: usize) {
-        self.buf.advance(cnt)
-    }
-
-    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]
-    }
-}
-
-impl fmt::Debug for MutByteBuf {
-    fn fmt(&self, fmt: &mut fmt::Formatter) -> fmt::Result {
-        self.bytes().fmt(fmt)
-    }
-}

src/buf/ext/chain.rs

@@ -0,0 +1,234 @@
+use crate::{Buf, BufMut};
+use crate::buf::IntoIter;
+
+use core::mem::MaybeUninit;
+
+#[cfg(feature = "std")]
+use std::io::{IoSlice};
+#[cfg(feature = "std")]
+use crate::buf::IoSliceMut;
+
+/// A `Chain` sequences two buffers.
+///
+/// `Chain` is an adapter that links two underlying buffers and provides a
+/// continuous view across both buffers. It is able to sequence either immutable
+/// buffers ([`Buf`] values) or mutable buffers ([`BufMut`] values).
+///
+/// This struct is generally created by calling [`Buf::chain`]. Please see that
+/// function's documentation for more detail.
+///
+/// # Examples
+///
+/// ```
+/// use bytes::{Bytes, Buf, buf::BufExt};
+///
+/// let mut buf = (&b"hello "[..])
+///     .chain(&b"world"[..]);
+///
+/// let full: Bytes = buf.to_bytes();
+/// assert_eq!(full[..], b"hello world"[..]);
+/// ```
+///
+/// [`Buf::chain`]: trait.Buf.html#method.chain
+/// [`Buf`]: trait.Buf.html
+/// [`BufMut`]: trait.BufMut.html
+#[derive(Debug)]
+pub struct Chain<T, U> {
+    a: T,
+    b: U,
+}
+
+impl<T, U> Chain<T, U> {
+    /// Creates a new `Chain` sequencing the provided values.
+    pub fn new(a: T, b: U) -> Chain<T, U> {
+        Chain {
+            a,
+            b,
+        }
+    }
+
+    /// Gets a reference to the first underlying `Buf`.
+    ///
+    /// # Examples
+    ///
+    /// ```
+    /// use bytes::buf::BufExt;
+    ///
+    /// let buf = (&b"hello"[..])
+    ///     .chain(&b"world"[..]);
+    ///
+    /// assert_eq!(buf.first_ref()[..], b"hello"[..]);
+    /// ```
+    pub fn first_ref(&self) -> &T {
+        &self.a
+    }
+
+    /// Gets a mutable reference to the first underlying `Buf`.
+    ///
+    /// # Examples
+    ///
+    /// ```
+    /// use bytes::{Buf, buf::BufExt};
+    ///
+    /// let mut buf = (&b"hello"[..])
+    ///     .chain(&b"world"[..]);
+    ///
+    /// buf.first_mut().advance(1);
+    ///
+    /// let full = buf.to_bytes();
+    /// assert_eq!(full, b"elloworld"[..]);
+    /// ```
+    pub fn first_mut(&mut self) -> &mut T {
+        &mut self.a
+    }
+
+    /// Gets a reference to the last underlying `Buf`.
+    ///
+    /// # Examples
+    ///
+    /// ```
+    /// use bytes::buf::BufExt;
+    ///
+    /// let buf = (&b"hello"[..])
+    ///     .chain(&b"world"[..]);
+    ///
+    /// assert_eq!(buf.last_ref()[..], b"world"[..]);
+    /// ```
+    pub fn last_ref(&self) -> &U {
+        &self.b
+    }
+
+    /// Gets a mutable reference to the last underlying `Buf`.
+    ///
+    /// # Examples
+    ///
+    /// ```
+    /// use bytes::{Buf, buf::BufExt};
+    ///
+    /// let mut buf = (&b"hello "[..])
+    ///     .chain(&b"world"[..]);
+    ///
+    /// buf.last_mut().advance(1);
+    ///
+    /// let full = buf.to_bytes();
+    /// assert_eq!(full, b"hello orld"[..]);
+    /// ```
+    pub fn last_mut(&mut self) -> &mut U {
+        &mut self.b
+    }
+
+    /// Consumes this `Chain`, returning the underlying values.
+    ///
+    /// # Examples
+    ///
+    /// ```
+    /// use bytes::buf::BufExt;
+    ///
+    /// let chain = (&b"hello"[..])
+    ///     .chain(&b"world"[..]);
+    ///
+    /// let (first, last) = chain.into_inner();
+    /// assert_eq!(first[..], b"hello"[..]);
+    /// assert_eq!(last[..], b"world"[..]);
+    /// ```
+    pub fn into_inner(self) -> (T, U) {
+        (self.a, self.b)
+    }
+}
+
+impl<T, U> Buf for Chain<T, U>
+    where T: Buf,
+          U: Buf,
+{
+    fn remaining(&self) -> usize {
+        self.a.remaining() + self.b.remaining()
+    }
+
+    fn bytes(&self) -> &[u8] {
+        if self.a.has_remaining() {
+            self.a.bytes()
+        } else {
+            self.b.bytes()
+        }
+    }
+
+    fn advance(&mut self, mut cnt: usize) {
+        let a_rem = self.a.remaining();
+
+        if a_rem != 0 {
+            if a_rem >= cnt {
+                self.a.advance(cnt);
+                return;
+            }
+
+            // Consume what is left of a
+            self.a.advance(a_rem);
+
+            cnt -= a_rem;
+        }
+
+        self.b.advance(cnt);
+    }
+
+    #[cfg(feature = "std")]
+    fn bytes_vectored<'a>(&'a self, dst: &mut [IoSlice<'a>]) -> usize {
+        let mut n = self.a.bytes_vectored(dst);
+        n += self.b.bytes_vectored(&mut dst[n..]);
+        n
+    }
+}
+
+impl<T, U> BufMut for Chain<T, U>
+    where T: BufMut,
+          U: BufMut,
+{
+    fn remaining_mut(&self) -> usize {
+        self.a.remaining_mut() + self.b.remaining_mut()
+    }
+
+    fn bytes_mut(&mut self) -> &mut [MaybeUninit<u8>] {
+        if self.a.has_remaining_mut() {
+            self.a.bytes_mut()
+        } else {
+            self.b.bytes_mut()
+        }
+    }
+
+    unsafe fn advance_mut(&mut self, mut cnt: usize) {
+        let a_rem = self.a.remaining_mut();
+
+        if a_rem != 0 {
+            if a_rem >= cnt {
+                self.a.advance_mut(cnt);
+                return;
+            }
+
+            // Consume what is left of a
+            self.a.advance_mut(a_rem);
+
+            cnt -= a_rem;
+        }
+
+        self.b.advance_mut(cnt);
+    }
+
+    #[cfg(feature = "std")]
+    fn bytes_vectored_mut<'a>(&'a mut self, dst: &mut [IoSliceMut<'a>]) -> usize {
+        let mut n = self.a.bytes_vectored_mut(dst);
+        n += self.b.bytes_vectored_mut(&mut dst[n..]);
+        n
+    }
+}
+
+impl<T, U> IntoIterator for Chain<T, U>
+where
+    T: Buf,
+    U: Buf,
+{
+    type Item = u8;
+    type IntoIter = IntoIter<Chain<T, U>>;
+
+    fn into_iter(self) -> Self::IntoIter {
+        IntoIter::new(self)
+    }
+}

src/buf/ext/limit.rs

@@ -0,0 +1,77 @@
+use crate::BufMut;
+
+use core::{cmp, mem::MaybeUninit};
+
+/// A `BufMut` adapter which limits the amount of bytes that can be written
+/// to an underlying buffer.
+#[derive(Debug)]
+pub struct Limit<T> {
+    inner: T,
+    limit: usize,
+}
+
+pub(super) fn new<T>(inner: T, limit: usize) -> Limit<T> {
+    Limit {
+        inner,
+        limit,
+    }
+}
+
+impl<T> Limit<T> {
+    /// Consumes this `Limit`, returning the underlying value.
+    pub fn into_inner(self) -> T {
+        self.inner
+    }
+
+    /// Gets a reference to the underlying `BufMut`.
+    ///
+    /// It is inadvisable to directly write to the underlying `BufMut`.
+    pub fn get_ref(&self) -> &T {
+        &self.inner
+    }
+
+    /// Gets a mutable reference to the underlying `BufMut`.
+    ///
+    /// It is inadvisable to directly write to the underlying `BufMut`.
+    pub fn get_mut(&mut self) -> &mut T {
+        &mut self.inner
+    }
+
+    /// Returns the maximum number of bytes that can be written
+    ///
+    /// # Note
+    ///
+    /// If the inner `BufMut` has fewer bytes than indicated by this method then
+    /// that is the actual number of available bytes.
+    pub fn limit(&self) -> usize {
+        self.limit
+    }
+
+    /// Sets the maximum number of bytes that can be written.
+    ///
+    /// # Note
+    ///
+    /// If the inner `BufMut` has fewer bytes than `lim` then that is the actual
+    /// number of available bytes.
+    pub fn set_limit(&mut self, lim: usize) {
+        self.limit = lim
+    }
+}
+
+impl<T: BufMut> BufMut for Limit<T> {
+    fn remaining_mut(&self) -> usize {
+        cmp::min(self.inner.remaining_mut(), self.limit)
+    }
+
+    fn bytes_mut(&mut self) -> &mut [MaybeUninit<u8>] {
+        let bytes = self.inner.bytes_mut();
+        let end = cmp::min(bytes.len(), self.limit);
+        &mut bytes[..end]
+    }
+
+    unsafe fn advance_mut(&mut self, cnt: usize) {
+        assert!(cnt <= self.limit);
+        self.inner.advance_mut(cnt);
+        self.limit -= cnt;
+    }
+}

src/buf/ext/mod.rs

@@ -0,0 +1,176 @@
+//! Extra utilities for `Buf` and `BufMut` types.
+
+use super::{Buf, BufMut};
+
+mod chain;
+mod limit;
+#[cfg(feature = "std")]
+mod reader;
+mod take;
+#[cfg(feature = "std")]
+mod writer;
+
+pub use self::limit::Limit;
+pub use self::take::Take;
+pub use self::chain::Chain;
+
+#[cfg(feature = "std")]
+pub use self::{reader::Reader, writer::Writer};
+
+/// Extra methods for implementations of `Buf`.
+pub trait BufExt: Buf {
+    /// Creates an adaptor which will read at most `limit` bytes from `self`.
+    ///
+    /// This function returns a new instance of `Buf` which will read at most
+    /// `limit` bytes.
+    ///
+    /// # Examples
+    ///
+    /// ```
+    /// use bytes::{Buf, BufMut, buf::BufExt};
+    ///
+    /// let mut buf = b"hello world"[..].take(5);
+    /// let mut dst = vec![];
+    ///
+    /// dst.put(&mut buf);
+    /// assert_eq!(dst, b"hello");
+    ///
+    /// let mut buf = buf.into_inner();
+    /// dst.clear();
+    /// dst.put(&mut buf);
+    /// assert_eq!(dst, b" world");
+    /// ```
+    fn take(self, limit: usize) -> Take<Self>
+        where Self: Sized
+    {
+        take::new(self, limit)
+    }
+
+    /// Creates an adaptor which will chain this buffer with another.
+    ///
+    /// The returned `Buf` instance will first consume all bytes from `self`.
+    /// Afterwards the output is equivalent to the output of next.
+    ///
+    /// # Examples
+    ///
+    /// ```
+    /// use bytes::{Buf, buf::BufExt};
+    ///
+    /// let mut chain = b"hello "[..].chain(&b"world"[..]);
+    ///
+    /// let full = chain.to_bytes();
+    /// assert_eq!(full.bytes(), b"hello world");
+    /// ```
+    fn chain<U: Buf>(self, next: U) -> Chain<Self, U>
+        where Self: Sized
+    {
+        Chain::new(self, next)
+    }
+
+    /// Creates an adaptor which implements the `Read` trait for `self`.
+    ///
+    /// This function returns a new value which implements `Read` by adapting
+    /// the `Read` trait functions to the `Buf` trait functions. Given that
+    /// `Buf` operations are infallible, none of the `Read` functions will
+    /// return with `Err`.
+    ///
+    /// # Examples
+    ///
+    /// ```
+    /// use bytes::{Buf, Bytes, buf::BufExt};
+    /// use std::io::Read;
+    ///
+    /// let buf = Bytes::from("hello world");
+    ///
+    /// let mut reader = buf.reader();
+    /// let mut dst = [0; 1024];
+    ///
+    /// let num = reader.read(&mut dst).unwrap();
+    ///
+    /// assert_eq!(11, num);
+    /// assert_eq!(&dst[..11], &b"hello world"[..]);
+    /// ```
+    #[cfg(feature = "std")]
+    fn reader(self) -> Reader<Self> where Self: Sized {
+        reader::new(self)
+    }
+}
+
+impl<B: Buf + ?Sized> BufExt for B {}
+
+/// Extra methods for implementations of `BufMut`.
+pub trait BufMutExt: BufMut {
+    /// Creates an adaptor which can write at most `limit` bytes to `self`.
+    ///
+    /// # Examples
+    ///
+    /// ```
+    /// use bytes::{BufMut, buf::BufMutExt};
+    ///
+    /// let arr = &mut [0u8; 128][..];
+    /// assert_eq!(arr.remaining_mut(), 128);
+    ///
+    /// let dst = arr.limit(10);
+    /// assert_eq!(dst.remaining_mut(), 10);
+    /// ```
+    fn limit(self, limit: usize) -> Limit<Self>
+        where Self: Sized
+    {
+        limit::new(self, limit)
+    }
+
+    /// Creates an adaptor which implements the `Write` trait for `self`.
+    ///
+    /// This function returns a new value which implements `Write` by adapting
+    /// the `Write` trait functions to the `BufMut` trait functions. Given that
+    /// `BufMut` operations are infallible, none of the `Write` functions will
+    /// return with `Err`.
+    ///
+    /// # Examples
+    ///
+    /// ```
+    /// use bytes::{BufMut, buf::BufMutExt};
+    /// use std::io::Write;
+    ///
+    /// let mut buf = vec![].writer();
+    ///
+    /// let num = buf.write(&b"hello world"[..]).unwrap();
+    /// assert_eq!(11, num);
+    ///
+    /// let buf = buf.into_inner();
+    ///
+    /// assert_eq!(*buf, b"hello world"[..]);
+    /// ```
+    #[cfg(feature = "std")]
+    fn writer(self) -> Writer<Self> where Self: Sized {
+        writer::new(self)
+    }
+
+    /// Creates an adapter which will chain this buffer with another.
+    ///
+    /// The returned `BufMut` instance will first write to all bytes from
+    /// `self`. Afterwards, it will write to `next`.
+    ///
+    /// # Examples
+    ///
+    /// ```
+    /// use bytes::{BufMut, buf::BufMutExt};
+    ///
+    /// let mut a = [0u8; 5];
+    /// let mut b = [0u8; 6];
+    ///
+    /// let mut chain = (&mut a[..]).chain_mut(&mut b[..]);
+    ///
+    /// chain.put_slice(b"hello world");
+    ///
+    /// assert_eq!(&a[..], b"hello");
+    /// assert_eq!(&b[..], b" world");
+    /// ```
+    fn chain_mut<U: BufMut>(self, next: U) -> Chain<Self, U>
+        where Self: Sized
+    {
+        Chain::new(self, next)
+    }
+}
+
+impl<B: BufMut + ?Sized> BufMutExt for B {}

src/buf/ext/reader.rs

@@ -0,0 +1,81 @@
+use crate::{Buf};
+
+use std::{cmp, io};
+
+/// A `Buf` adapter which implements `io::Read` for the inner value.
+///
+/// This struct is generally created by calling `reader()` on `Buf`. See
+/// documentation of [`reader()`](trait.Buf.html#method.reader) for more
+/// details.
+#[derive(Debug)]
+pub struct Reader<B> {
+    buf: B,
+}
+
+pub fn new<B>(buf: B) -> Reader<B> {
+    Reader { buf }
+}
+
+impl<B: Buf> Reader<B> {
+    /// Gets a reference to the underlying `Buf`.
+    ///
+    /// It is inadvisable to directly read from the underlying `Buf`.
+    ///
+    /// # Examples
+    ///
+    /// ```rust
+    /// use bytes::buf::BufExt;
+    ///
+    /// let mut buf = b"hello world".reader();
+    ///
+    /// assert_eq!(b"hello world", buf.get_ref());
+    /// ```
+    pub fn get_ref(&self) -> &B {
+        &self.buf
+    }
+
+    /// Gets a mutable reference to the underlying `Buf`.
+    ///
+    /// It is inadvisable to directly read from the underlying `Buf`.
+    pub fn get_mut(&mut self) -> &mut B {
+        &mut self.buf
+    }
+
+    /// Consumes this `Reader`, returning the underlying value.
+    ///
+    /// # Examples
+    ///
+    /// ```rust
+    /// use bytes::{Buf, buf::BufExt};
+    /// use std::io;
+    ///
+    /// let mut buf = b"hello world".reader();
+    /// let mut dst = vec![];
+    ///
+    /// io::copy(&mut buf, &mut dst).unwrap();
+    ///
+    /// let buf = buf.into_inner();
+    /// assert_eq!(0, buf.remaining());
+    /// ```
+    pub fn into_inner(self) -> B {
+        self.buf
+    }
+}
+
+impl<B: Buf + Sized> io::Read for Reader<B> {
+    fn read(&mut self, dst: &mut [u8]) -> io::Result<usize> {
+        let len = cmp::min(self.buf.remaining(), dst.len());
+
+        Buf::copy_to_slice(&mut self.buf, &mut dst[0..len]);
+        Ok(len)
+    }
+}
+
+impl<B: Buf + Sized> io::BufRead for Reader<B> {
+    fn fill_buf(&mut self) -> io::Result<&[u8]> {
+        Ok(self.buf.bytes())
+    }
+    fn consume(&mut self, amt: usize) {
+        self.buf.advance(amt)
+    }
+}

src/buf/ext/take.rs

@@ -0,0 +1,150 @@
+use crate::Buf;
+
+use core::cmp;
+
+/// A `Buf` adapter which limits the bytes read from an underlying buffer.
+///
+/// This struct is generally created by calling `take()` on `Buf`. See
+/// documentation of [`take()`](trait.Buf.html#method.take) for more details.
+#[derive(Debug)]
+pub struct Take<T> {
+    inner: T,
+    limit: usize,
+}
+
+pub fn new<T>(inner: T, limit: usize) -> Take<T> {
+    Take {
+        inner,
+        limit,
+    }
+}
+
+impl<T> Take<T> {
+    /// Consumes this `Take`, returning the underlying value.
+    ///
+    /// # Examples
+    ///
+    /// ```rust
+    /// use bytes::buf::{Buf, BufMut, BufExt};
+    ///
+    /// let mut buf = b"hello world".take(2);
+    /// let mut dst = vec![];
+    ///
+    /// dst.put(&mut buf);
+    /// assert_eq!(*dst, b"he"[..]);
+    ///
+    /// let mut buf = buf.into_inner();
+    ///
+    /// dst.clear();
+    /// dst.put(&mut buf);
+    /// assert_eq!(*dst, b"llo world"[..]);
+    /// ```
+    pub fn into_inner(self) -> T {
+        self.inner
+    }
+
+    /// Gets a reference to the underlying `Buf`.
+    ///
+    /// It is inadvisable to directly read from the underlying `Buf`.
+    ///
+    /// # Examples
+    ///
+    /// ```rust
+    /// use bytes::{Buf, buf::BufExt};
+    ///
+    /// let mut buf = b"hello world".take(2);
+    ///
+    /// assert_eq!(11, buf.get_ref().remaining());
+    /// ```
+    pub fn get_ref(&self) -> &T {
+        &self.inner
+    }
+
+    /// Gets a mutable reference to the underlying `Buf`.
+    ///
+    /// It is inadvisable to directly read from the underlying `Buf`.
+    ///
+    /// # Examples
+    ///
+    /// ```rust
+    /// use bytes::{Buf, BufMut, buf::BufExt};
+    ///
+    /// let mut buf = b"hello world".take(2);
+    /// let mut dst = vec![];
+    ///
+    /// buf.get_mut().advance(2);
+    ///
+    /// dst.put(&mut buf);
+    /// assert_eq!(*dst, b"ll"[..]);
+    /// ```
+    pub fn get_mut(&mut self) -> &mut T {
+        &mut self.inner
+    }
+
+    /// Returns the maximum number of bytes that can be read.
+    ///
+    /// # Note
+    ///
+    /// If the inner `Buf` has fewer bytes than indicated by this method then
+    /// that is the actual number of available bytes.
+    ///
+    /// # Examples
+    ///
+    /// ```rust
+    /// use bytes::{Buf, buf::BufExt};
+    ///
+    /// let mut buf = b"hello world".take(2);
+    ///
+    /// assert_eq!(2, buf.limit());
+    /// assert_eq!(b'h', buf.get_u8());
+    /// assert_eq!(1, buf.limit());
+    /// ```
+    pub fn limit(&self) -> usize {
+        self.limit
+    }
+
+    /// Sets the maximum number of bytes that can be read.
+    ///
+    /// # Note
+    ///
+    /// If the inner `Buf` has fewer bytes than `lim` then that is the actual
+    /// number of available bytes.
+    ///
+    /// # Examples
+    ///
+    /// ```rust
+    /// use bytes::{Buf, BufMut, buf::BufExt};
+    ///
+    /// let mut buf = b"hello world".take(2);
+    /// let mut dst = vec![];
+    ///
+    /// dst.put(&mut buf);
+    /// assert_eq!(*dst, b"he"[..]);
+    ///
+    /// dst.clear();
+    ///
+    /// buf.set_limit(3);
+    /// dst.put(&mut buf);
+    /// assert_eq!(*dst, b"llo"[..]);
+    /// ```
+    pub fn set_limit(&mut self, lim: usize) {
+        self.limit = lim
+    }
+}
+
+impl<T: Buf> Buf for Take<T> {
+    fn remaining(&self) -> usize {
+        cmp::min(self.inner.remaining(), self.limit)
+    }
+
+    fn bytes(&self) -> &[u8] {
+        let bytes = self.inner.bytes();
+        &bytes[..cmp::min(bytes.len(), self.limit)]
+    }
+
+    fn advance(&mut self, cnt: usize) {
+        assert!(cnt <= self.limit);
+        self.inner.advance(cnt);
+        self.limit -= cnt;
+    }
+}

src/buf/ext/writer.rs

@@ -0,0 +1,88 @@
+use crate::BufMut;
+
+use std::{cmp, io};
+
+/// A `BufMut` adapter which implements `io::Write` for the inner value.
+///
+/// This struct is generally created by calling `writer()` on `BufMut`. See
+/// documentation of [`writer()`](trait.BufMut.html#method.writer) for more
+/// details.
+#[derive(Debug)]
+pub struct Writer<B> {
+    buf: B,
+}
+
+pub fn new<B>(buf: B) -> Writer<B> {
+    Writer { buf }
+}
+
+impl<B: BufMut> Writer<B> {
+    /// Gets a reference to the underlying `BufMut`.
+    ///
+    /// It is inadvisable to directly write to the underlying `BufMut`.
+    ///
+    /// # Examples
+    ///
+    /// ```rust
+    /// use bytes::buf::BufMutExt;
+    ///
+    /// let mut buf = Vec::with_capacity(1024).writer();
+    ///
+    /// assert_eq!(1024, buf.get_ref().capacity());
+    /// ```
+    pub fn get_ref(&self) -> &B {
+        &self.buf
+    }
+
+    /// Gets a mutable reference to the underlying `BufMut`.
+    ///
+    /// It is inadvisable to directly write to the underlying `BufMut`.
+    ///
+    /// # Examples
+    ///
+    /// ```rust
+    /// use bytes::buf::BufMutExt;
+    ///
+    /// let mut buf = vec![].writer();
+    ///
+    /// buf.get_mut().reserve(1024);
+    ///
+    /// assert_eq!(1024, buf.get_ref().capacity());
+    /// ```
+    pub fn get_mut(&mut self) -> &mut B {
+        &mut self.buf
+    }
+
+    /// Consumes this `Writer`, returning the underlying value.
+    ///
+    /// # Examples
+    ///
+    /// ```rust
+    /// use bytes::buf::BufMutExt;
+    /// use std::io;
+    ///
+    /// let mut buf = vec![].writer();
+    /// let mut src = &b"hello world"[..];
+    ///
+    /// io::copy(&mut src, &mut buf).unwrap();
+    ///
+    /// let buf = buf.into_inner();
+    /// assert_eq!(*buf, b"hello world"[..]);
+    /// ```
+    pub fn into_inner(self) -> B {
+        self.buf
+    }
+}
+
+impl<B: BufMut + Sized> io::Write for Writer<B> {
+    fn write(&mut self, src: &[u8]) -> io::Result<usize> {
+        let n = cmp::min(self.buf.remaining_mut(), src.len());
+
+        self.buf.put(&src[0..n]);
+        Ok(n)
+    }
+
+    fn flush(&mut self) -> io::Result<()> {
+        Ok(())
+    }
+}

src/buf/iter.rs

@@ -0,0 +1,133 @@
+use crate::Buf;
+
+/// Iterator over the bytes contained by the buffer.
+///
+/// This struct is created by the [`iter`] method on [`Buf`].
+///
+/// # Examples
+///
+/// Basic usage:
+///
+/// ```
+/// use bytes::{Buf, Bytes};
+///
+/// let buf = Bytes::from(&b"abc"[..]);
+/// let mut iter = buf.into_iter();
+///
+/// assert_eq!(iter.next(), Some(b'a'));
+/// assert_eq!(iter.next(), Some(b'b'));
+/// assert_eq!(iter.next(), Some(b'c'));
+/// assert_eq!(iter.next(), None);
+/// ```
+///
+/// [`iter`]: trait.Buf.html#method.iter
+/// [`Buf`]: trait.Buf.html
+#[derive(Debug)]
+pub struct IntoIter<T> {
+    inner: T,
+}
+
+impl<T> IntoIter<T> {
+    /// Creates an iterator over the bytes contained by the buffer.
+    ///
+    /// # Examples
+    ///
+    /// ```
+    /// use bytes::{Buf, Bytes};
+    /// use bytes::buf::IntoIter;
+    ///
+    /// let buf = Bytes::from_static(b"abc");
+    /// let mut iter = IntoIter::new(buf);
+    ///
+    /// assert_eq!(iter.next(), Some(b'a'));
+    /// assert_eq!(iter.next(), Some(b'b'));
+    /// assert_eq!(iter.next(), Some(b'c'));
+    /// assert_eq!(iter.next(), None);
+    /// ```
+    pub fn new(inner: T) -> IntoIter<T> {
+        IntoIter { inner }
+    }
+    /// Consumes this `IntoIter`, returning the underlying value.
+    ///
+    /// # Examples
+    ///
+    /// ```rust
+    /// use bytes::{Buf, Bytes};
+    ///
+    /// let buf = Bytes::from(&b"abc"[..]);
+    /// let mut iter = buf.into_iter();
+    ///
+    /// assert_eq!(iter.next(), Some(b'a'));
+    ///
+    /// let buf = iter.into_inner();
+    /// assert_eq!(2, buf.remaining());
+    /// ```
+    pub fn into_inner(self) -> T {
+        self.inner
+    }
+
+    /// Gets a reference to the underlying `Buf`.
+    ///
+    /// It is inadvisable to directly read from the underlying `Buf`.
+    ///
+    /// # Examples
+    ///
+    /// ```rust
+    /// use bytes::{Buf, Bytes};
+    ///
+    /// let buf = Bytes::from(&b"abc"[..]);
+    /// let mut iter = buf.into_iter();
+    ///
+    /// assert_eq!(iter.next(), Some(b'a'));
+    ///
+    /// assert_eq!(2, iter.get_ref().remaining());
+    /// ```
+    pub fn get_ref(&self) -> &T {
+        &self.inner
+    }
+
+    /// Gets a mutable reference to the underlying `Buf`.
+    ///
+    /// It is inadvisable to directly read from the underlying `Buf`.
+    ///
+    /// # Examples
+    ///
+    /// ```rust
+    /// use bytes::{Buf, BytesMut};
+    ///
+    /// let buf = BytesMut::from(&b"abc"[..]);
+    /// let mut iter = buf.into_iter();
+    ///
+    /// assert_eq!(iter.next(), Some(b'a'));
+    ///
+    /// iter.get_mut().advance(1);
+    ///
+    /// assert_eq!(iter.next(), Some(b'c'));
+    /// ```
+    pub fn get_mut(&mut self) -> &mut T {
+        &mut self.inner
+    }
+}
+
+
+impl<T: Buf> Iterator for IntoIter<T> {
+    type Item = u8;
+
+    fn next(&mut self) -> Option<u8> {
+        if !self.inner.has_remaining() {
+            return None;
+        }
+
+        let b = self.inner.bytes()[0];
+        self.inner.advance(1);
+
+        Some(b)
+    }
+
+    fn size_hint(&self) -> (usize, Option<usize>) {
+        let rem = self.inner.remaining();
+        (rem, Some(rem))
+    }
+}
+
+impl<T: Buf> ExactSizeIterator for IntoIter<T> { }

src/buf/mod.rs

@@ -1,430 +1,31 @@
-mod byte;
-mod ring;
-mod sink;
-mod slice;
-mod source;
-mod take;
+//! Utilities for working with buffers.
+//!
+//! A buffer is any structure that contains a sequence of bytes. The bytes may
+//! or may not be stored in contiguous memory. This module contains traits used
+//! to abstract over buffers as well as utilities for working with buffer types.
+//!
+//! # `Buf`, `BufMut`
+//!
+//! These are the two foundational traits for abstractly working with buffers.
+//! They can be thought as iterators for byte structures. They offer additional
+//! performance over `Iterator` by providing an API optimized for byte slices.
+//!
+//! See [`Buf`] and [`BufMut`] for more details.
+//!
+//! [rope]: https://en.wikipedia.org/wiki/Rope_(data_structure)
+//! [`Buf`]: trait.Buf.html
+//! [`BufMut`]: trait.BufMut.html
+
+mod buf_impl;
+mod buf_mut;
+pub mod ext;
+mod iter;
+mod vec_deque;
+
+pub use self::buf_impl::Buf;
+pub use self::buf_mut::BufMut;
+pub use self::ext::{BufExt, BufMutExt};
+#[cfg(feature = "std")]
+pub use self::buf_mut::IoSliceMut;
+pub use self::iter::IntoIter;
 
-pub use self::byte::{ByteBuf, MutByteBuf, ROByteBuf};
-pub use self::ring::RingBuf;
-pub use self::slice::{SliceBuf, MutSliceBuf};
-pub use self::take::Take;
-
-use {BufError, RopeBuf};
-use std::{cmp, fmt, io, ptr, usize};
-
-/// A trait for values that provide sequential read access to bytes.
-pub trait Buf {
-
-    /// Returns the number of bytes that can be accessed from the Buf
-    fn remaining(&self) -> usize;
-
-    /// Returns a slice starting at the current Buf position and of length
-    /// between 0 and `Buf::remaining()`.
-    fn bytes<'a>(&'a self) -> &'a [u8];
-
-    /// Advance the internal cursor of the Buf
-    fn advance(&mut self, cnt: usize);
-
-    /// Returns true if there are any more bytes to consume
-    fn has_remaining(&self) -> bool {
-        self.remaining() > 0
-    }
-
-    /// Read bytes from the `Buf` into the given slice and advance the cursor by
-    /// the number of bytes read.
-    /// Returns the number of bytes read.
-    ///
-    /// ```
-    /// use bytes::{SliceBuf, Buf};
-    ///
-    /// let mut buf = SliceBuf::wrap(b"hello world");
-    /// let mut dst = [0; 5];
-    ///
-    /// buf.read_slice(&mut dst);
-    /// assert_eq!(b"hello", &dst);
-    /// assert_eq!(6, buf.remaining());
-    /// ```
-    fn read_slice(&mut self, dst: &mut [u8]) -> usize {
-        let mut off = 0;
-        let len = cmp::min(dst.len(), self.remaining());
-
-        while off < len {
-            let cnt;
-
-            unsafe {
-                let src = self.bytes();
-                cnt = cmp::min(src.len(), len - off);
-
-                ptr::copy_nonoverlapping(
-                    src.as_ptr(), dst[off..].as_mut_ptr(), cnt);
-
-                off += src.len();
-            }
-
-            self.advance(cnt);
-        }
-
-        len
-    }
-
-    /// Read a single byte from the `Buf`
-    fn read_byte(&mut self) -> Option<u8> {
-        let mut dst = [0];
-
-        if self.read_slice(&mut dst) == 0 {
-            return None;
-        }
-
-        Some(dst[0])
-    }
-}
-
-/// An extension trait providing extra functions applicable to all `Buf` values.
-pub trait BufExt {
-
-    /// Read bytes from this Buf into the given sink and advance the cursor by
-    /// the number of bytes read.
-    fn read<S: Sink>(&mut self, dst: S) -> Result<usize, S::Error>;
-}
-
-/// A trait for values that provide sequential write access to bytes.
-pub trait MutBuf : Sized {
-
-    /// Returns the number of bytes that can be written to the MutBuf
-    fn remaining(&self) -> usize;
-
-    /// Advance the internal cursor of the MutBuf
-    unsafe fn advance(&mut self, cnt: usize);
-
-    /// Returns true iff there is any more space for bytes to be written
-    fn has_remaining(&self) -> bool {
-        self.remaining() > 0
-    }
-
-    /// Returns a mutable slice starting at the current MutBuf position and of
-    /// length between 0 and `MutBuf::remaining()`.
-    ///
-    /// The returned byte slice may represent uninitialized memory.
-    unsafe fn mut_bytes<'a>(&'a mut self) -> &'a mut [u8];
-
-    /// Write bytes from the given slice into the `MutBuf` and advance the
-    /// cursor by the number of bytes written.
-    /// Returns the number of bytes written.
-    ///
-    /// ```
-    /// use bytes::{MutSliceBuf, Buf, MutBuf};
-    ///
-    /// let mut dst = [0; 6];
-    ///
-    /// {
-    ///     let mut buf = MutSliceBuf::wrap(&mut dst);
-    ///     buf.write_slice(b"hello");
-    ///
-    ///     assert_eq!(1, buf.remaining());
-    /// }
-    ///
-    /// assert_eq!(b"hello\0", &dst);
-    /// ```
-    fn write_slice(&mut self, src: &[u8]) -> usize {
-        let mut off = 0;
-        let len = cmp::min(src.len(), self.remaining());
-
-        while off < len {
-            let cnt;
-
-            unsafe {
-                let dst = self.mut_bytes();
-                cnt = cmp::min(dst.len(), len - off);
-
-                ptr::copy_nonoverlapping(
-                    src[off..].as_ptr(),
-                    dst.as_mut_ptr(),
-                    cnt);
-
-                off += cnt;
-
-            }
-
-            unsafe { self.advance(cnt); }
-        }
-
-        len
-    }
-
-    /// Write a single byte to the `MuBuf`
-    fn write_byte(&mut self, byte: u8) -> bool {
-        let src = [byte];
-
-        if self.write_slice(&src) == 0 {
-            return false;
-        }
-
-        true
-    }
-}
-
-/// An extension trait providing extra functions applicable to all `MutBuf` values.
-pub trait MutBufExt {
-
-    /// Write bytes from the given source into the current `MutBuf` and advance
-    /// the cursor by the number of bytes written.
-    fn write<S: Source>(&mut self, src: S) -> Result<usize, S::Error>;
-}
-
-/*
- *
- * ===== *Ext impls =====
- *
- */
-
-impl<B: Buf> BufExt for B {
-    fn read<S: Sink>(&mut self, dst: S) -> Result<usize, S::Error> {
-        dst.sink(self)
-    }
-}
-
-impl<B: MutBuf> MutBufExt for B {
-    fn write<S: Source>(&mut self, src: S) -> Result<usize, S::Error> {
-        src.fill(self)
-    }
-}
-
-/*
- *
- * ===== Sink / Source =====
- *
- */
-
-/// A value that reads bytes from a Buf into itself
-pub trait Sink {
-    type Error;
-
-    fn sink<B: Buf>(self, buf: &mut B) -> Result<usize, Self::Error>;
-}
-
-/// A value that writes bytes from itself into a `MutBuf`.
-pub trait Source {
-    type Error;
-
-    fn fill<B: MutBuf>(self, buf: &mut B) -> Result<usize, Self::Error>;
-}
-
-impl<'a> Sink for &'a mut [u8] {
-    type Error = BufError;
-
-    fn sink<B: Buf>(self, buf: &mut B) -> Result<usize, BufError> {
-        Ok(buf.read_slice(self))
-    }
-}
-
-impl<'a> Sink for &'a mut Vec<u8> {
-    type Error = BufError;
-
-    fn sink<B: Buf>(self, buf: &mut B) -> Result<usize, BufError> {
-        use std::slice;
-
-        self.clear();
-
-        let rem = buf.remaining();
-        let cap = self.capacity();
-
-        // Ensure that the vec is big enough
-        if rem > self.capacity() {
-            self.reserve(rem - cap);
-        }
-
-        unsafe {
-            {
-                let dst = &mut self[..];
-                let cnt = buf.read_slice(slice::from_raw_parts_mut(dst.as_mut_ptr(), rem));
-
-                debug_assert!(cnt == rem);
-            }
-
-            self.set_len(rem);
-        }
-
-        Ok(rem)
-    }
-}
-
-impl<'a> Source for &'a [u8] {
-    type Error = BufError;
-
-    fn fill<B: MutBuf>(self, buf: &mut B) -> Result<usize, BufError> {
-        Ok(buf.write_slice(self))
-    }
-}
-
-impl<'a> Source for &'a Vec<u8> {
-    type Error = BufError;
-
-    fn fill<B: MutBuf>(self, buf: &mut B) -> Result<usize, BufError> {
-        Ok(buf.write_slice(self.as_ref()))
-    }
-}
-
-
-impl<'a, R: io::Read+'a> Source for &'a mut R {
-    type Error = io::Error;
-
-    fn fill<B: MutBuf>(self, buf: &mut B) -> Result<usize, io::Error> {
-        let mut cnt = 0;
-
-        while buf.has_remaining() {
-            let i = try!(self.read(unsafe { buf.mut_bytes() }));
-
-            if i == 0 {
-                break;
-            }
-
-            unsafe { buf.advance(i); }
-            cnt += i;
-        }
-
-        Ok(cnt)
-    }
-}
-
-/*
- *
- * ===== Buf impls =====
- *
- */
-
-impl Buf for Box<Buf+'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+'static> {
-    fn fmt(&self, fmt: &mut fmt::Formatter) -> fmt::Result {
-        write!(fmt, "Box<Buf> {{ remaining: {} }}", self.remaining())
-    }
-}
-
-impl Buf for io::Cursor<Vec<u8>> {
-    fn remaining(&self) -> usize {
-        self.get_ref().len() - self.position() as usize
-    }
-
-    fn bytes(&self) -> &[u8] {
-        let pos = self.position() as usize;
-        &(&self.get_ref())[pos..]
-    }
-
-    fn advance(&mut self, cnt: usize) {
-        let pos = self.position() as usize;
-        let pos = cmp::min(self.get_ref().len(), pos + cnt);
-        self.set_position(pos as u64);
-    }
-}
-
-impl MutBuf for Vec<u8> {
-    fn remaining(&self) -> usize {
-        usize::MAX - self.len()
-    }
-
-    unsafe fn advance(&mut self, cnt: usize) {
-        let len = self.len() + cnt;
-
-        if len > self.capacity() {
-            // Reserve additional
-            // TODO: Should this case panic?
-            let cap = self.capacity();
-            self.reserve(cap - len);
-        }
-
-        self.set_len(len);
-    }
-
-    unsafe fn mut_bytes(&mut self) -> &mut [u8] {
-        use std::slice;
-
-        if self.capacity() == self.len() {
-            self.reserve(64); // Grow the vec
-        }
-
-        let cap = self.capacity();
-        let len = self.len();
-
-        let ptr = self.as_mut_ptr();
-        &mut slice::from_raw_parts_mut(ptr, cap)[len..]
-    }
-}
-
-impl<'a> Buf for io::Cursor<&'a [u8]> {
-    fn remaining(&self) -> usize {
-        self.get_ref().len() - self.position() as usize
-    }
-
-    fn bytes(&self) -> &[u8] {
-        let pos = self.position() as usize;
-        &(&self.get_ref())[pos..]
-    }
-
-    fn advance(&mut self, cnt: usize) {
-        let pos = self.position() as usize;
-        let pos = cmp::min(self.get_ref().len(), pos + cnt);
-        self.set_position(pos as u64);
-    }
-}
-
-/*
- *
- * ===== Read impls =====
- *
- */
-
-macro_rules! impl_read {
-    ($ty:ty) => {
-        impl io::Read for $ty {
-            fn read(&mut self, buf: &mut [u8]) -> io::Result<usize> {
-                if !self.has_remaining() {
-                    return Ok(0);
-                }
-
-                Ok(self.read_slice(buf))
-            }
-        }
-    }
-}
-
-impl_read!(ByteBuf);
-impl_read!(ROByteBuf);
-impl_read!(RopeBuf);
-impl_read!(Box<Buf+'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

@@ -1,250 +0,0 @@
-use {alloc, Buf, MutBuf};
-use std::{cmp, fmt, io, ptr};
-
-enum Mark {
-    NoMark,
-    At { pos: usize, len: usize },
-}
-
-/// Buf backed by a continous chunk of memory. Maintains a read cursor and a
-/// write cursor. When reads and writes reach the end of the allocated buffer,
-/// wraps around to the start.
-///
-/// This type is suited for use cases where reads and writes are intermixed.
-pub struct RingBuf {
-    ptr: alloc::MemRef,  // Pointer to the memory
-    cap: usize,          // Capacity of the buffer
-    pos: usize,          // Offset of read cursor
-    len: usize,          // Number of bytes to read
-    mark: Mark,          // Marked read position
-}
-
-// TODO: There are most likely many optimizations that can be made
-impl RingBuf {
-    /// Allocates a new `RingBuf` with the specified capacity.
-    pub fn new(mut capacity: usize) -> RingBuf {
-        // Handle the 0 length buffer case
-        if capacity == 0 {
-            return RingBuf {
-                ptr: alloc::MemRef::none(),
-                cap: 0,
-                pos: 0,
-                len: 0,
-                mark: Mark::NoMark,
-            }
-        }
-
-        // Round to the next power of 2 for better alignment
-        capacity = capacity.next_power_of_two();
-
-        let mem = alloc::heap(capacity as usize);
-
-        RingBuf {
-            ptr: mem,
-            cap: capacity,
-            pos: 0,
-            len: 0,
-            mark: Mark::NoMark,
-        }
-    }
-
-    /// Returns `true` if the buf cannot accept any further writes.
-    pub fn is_full(&self) -> bool {
-        self.cap == self.len
-    }
-
-    /// Returns `true` if the buf cannot accept any further reads.
-    pub fn is_empty(&self) -> bool {
-        self.len == 0
-    }
-
-    /// Returns the number of bytes that the buf can hold.
-    pub fn capacity(&self) -> usize {
-        self.cap
-    }
-
-    /// Marks the current read location.
-    ///
-    /// Together with `reset`, this can be used to read from a section of the
-    /// buffer multiple times. The mark will be cleared if it is overwritten
-    /// during a write.
-    pub fn mark(&mut self) {
-        self.mark = Mark::At { pos: self.pos, len: self.len };
-    }
-
-    /// 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){
-        match self.mark {
-            Mark::NoMark => panic!("no mark set"),
-            Mark::At {pos, len} => {
-                self.pos = pos;
-                self.len = len;
-                self.mark = Mark::NoMark;
-            }
-        }
-    }
-
-    /// Resets all internal state to the initial state.
-    pub fn clear(&mut self) {
-        self.pos = 0;
-        self.len = 0;
-        self.mark = Mark::NoMark;
-    }
-
-    /// Returns the number of bytes remaining to read.
-    fn read_remaining(&self) -> usize {
-        self.len
-    }
-
-    /// Returns the remaining write capacity until which the buf becomes full.
-    fn write_remaining(&self) -> usize {
-        self.cap - self.len
-    }
-
-    fn advance_reader(&mut self, mut cnt: usize) {
-        if self.cap == 0 {
-            return;
-        }
-        cnt = cmp::min(cnt, self.read_remaining());
-
-        self.pos += cnt;
-        self.pos %= self.cap;
-        self.len -= cnt;
-    }
-
-    fn advance_writer(&mut self, mut cnt: usize) {
-        cnt = cmp::min(cnt, self.write_remaining());
-        self.len += cnt;
-
-        // Adjust the mark to account for bytes written.
-        if let Mark::At { ref mut len, .. } = self.mark {
-            *len += cnt;
-        }
-
-        // Clear the mark if we've written past it.
-        if let Mark::At { len, .. } = self.mark {
-            if len > self.cap {
-                self.mark = Mark::NoMark;
-            }
-        }
-    }
-}
-
-impl Clone for RingBuf {
-    fn clone(&self) -> RingBuf {
-        use std::cmp;
-
-        let mut ret = RingBuf::new(self.cap);
-
-        ret.pos = self.pos;
-        ret.len = self.len;
-
-        unsafe {
-            let to = self.pos + self.len;
-
-            if to > self.cap {
-                ptr::copy(self.ptr.ptr() as *const u8, ret.ptr.ptr(), to % self.cap);
-            }
-
-            ptr::copy(
-                self.ptr.ptr().offset(self.pos as isize) as *const u8,
-                ret.ptr.ptr().offset(self.pos as isize),
-                cmp::min(self.len, self.cap - self.pos));
-        }
-
-        ret
-    }
-
-    // TODO: an improved version of clone_from is possible that potentially
-    // re-uses the buffer
-}
-
-impl fmt::Debug for RingBuf {
-    fn fmt(&self, fmt: &mut fmt::Formatter) -> fmt::Result {
-        write!(fmt, "RingBuf[.. {}]", self.len)
-    }
-}
-
-impl Buf for RingBuf {
-
-    fn remaining(&self) -> usize {
-        self.read_remaining()
-    }
-
-    fn bytes(&self) -> &[u8] {
-        let mut to = self.pos + self.len;
-
-        if to > self.cap {
-            to = self.cap
-        }
-
-        &self.ptr.bytes()[self.pos .. to]
-    }
-
-    fn advance(&mut self, cnt: usize) {
-        self.advance_reader(cnt)
-    }
-}
-
-impl MutBuf for RingBuf {
-
-    fn remaining(&self) -> usize {
-        self.write_remaining()
-    }
-
-    unsafe fn advance(&mut self, cnt: usize) {
-        self.advance_writer(cnt)
-    }
-
-    unsafe fn mut_bytes(&mut self) -> &mut [u8] {
-        if self.cap == 0 {
-            return self.ptr.bytes_mut();
-        }
-        let mut from;
-        let mut to;
-
-        from = self.pos + self.len;
-        from %= self.cap;
-
-        to = from + <Self as MutBuf>::remaining(&self);
-
-        if to >= self.cap {
-            to = self.cap;
-        }
-
-        &mut self.ptr.bytes_mut()[from..to]
-    }
-}
-
-impl io::Read for RingBuf {
-    fn read(&mut self, buf: &mut [u8]) -> io::Result<usize> {
-        if !Buf::has_remaining(self) {
-            return Ok(0);
-        }
-
-        Ok(self.read_slice(buf))
-    }
-}
-
-impl io::Write for RingBuf {
-    fn write(&mut self, buf: &[u8]) -> io::Result<usize> {
-        if !MutBuf::has_remaining(self) {
-            return Ok(0);
-        }
-
-        Ok(self.write_slice(buf))
-    }
-
-    fn flush(&mut self) -> io::Result<()> {
-        Ok(())
-    }
-}
-
-unsafe impl Send for RingBuf { }

src/buf/slice.rs

@@ -1,59 +0,0 @@
-use std::cmp;
-use {Buf, MutBuf};
-
-// TODO: Rename -> Cursor. Use as buf for various byte strings
-
-pub struct SliceBuf<'a> {
-    bytes: &'a [u8],
-    pos: usize
-}
-
-impl<'a> SliceBuf<'a> {
-    pub fn wrap(bytes: &'a [u8]) -> SliceBuf<'a> {
-        SliceBuf { bytes: bytes, pos: 0 }
-    }
-}
-
-impl<'a> Buf for SliceBuf<'a> {
-    fn remaining(&self) -> usize {
-        self.bytes.len() - self.pos
-    }
-
-    fn bytes<'b>(&'b self) -> &'b [u8] {
-        &self.bytes[self.pos..]
-    }
-
-    fn advance(&mut self, mut cnt: usize) {
-        cnt = cmp::min(cnt, self.remaining());
-        self.pos += cnt;
-    }
-}
-
-pub struct MutSliceBuf<'a> {
-    bytes: &'a mut [u8],
-    pos: usize
-}
-
-impl<'a> MutSliceBuf<'a> {
-    pub fn wrap(bytes: &'a mut [u8]) -> MutSliceBuf<'a> {
-        MutSliceBuf {
-            bytes: bytes,
-            pos: 0
-        }
-    }
-}
-
-impl<'a> MutBuf for MutSliceBuf<'a> {
-    fn remaining(&self) -> usize {
-        self.bytes.len() - self.pos
-    }
-
-    unsafe fn advance(&mut self, mut cnt: usize) {
-        cnt = cmp::min(cnt, self.remaining());
-        self.pos += cnt;
-    }
-
-    unsafe fn mut_bytes<'b>(&'b mut self) -> &'b mut [u8] {
-        &mut self.bytes[self.pos..]
-    }
-}

src/buf/take.rs

@@ -1,79 +0,0 @@
-use buf::{Buf, MutBuf};
-use std::{cmp, io};
-
-#[derive(Debug)]
-pub struct Take<T> {
-    inner: T,
-    limit: usize,
-}
-
-impl<T> Take<T> {
-    pub fn new(inner: T, limit: usize) -> Take<T> {
-        Take {
-            inner: inner,
-            limit: limit,
-        }
-    }
-
-    pub fn into_inner(self) -> T {
-        self.inner
-    }
-
-    pub fn get_ref(&self) -> &T {
-        &self.inner
-    }
-
-    pub fn get_mut(&mut self) -> &mut T {
-        &mut self.inner
-    }
-
-    pub fn limit(&self) -> usize {
-        self.limit
-    }
-
-    pub fn set_limit(&mut self, lim: usize) {
-        self.limit = lim
-    }
-}
-
-impl<T: Buf> Buf for Take<T> {
-    fn remaining(&self) -> usize {
-        cmp::min(self.inner.remaining(), self.limit)
-    }
-
-    fn bytes<'a>(&'a self) -> &'a [u8] {
-        &self.inner.bytes()[..self.limit]
-    }
-
-    fn advance(&mut self, cnt: usize) {
-        let cnt = cmp::min(cnt, self.limit);
-        self.limit -= cnt;
-        self.inner.advance(cnt);
-    }
-}
-
-impl<T: 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)
-    }
-
-    unsafe fn mut_bytes<'a>(&'a mut self) -> &'a mut [u8] {
-        &mut self.inner.mut_bytes()[..self.limit]
-    }
-
-    unsafe fn advance(&mut self, cnt: usize) {
-        let cnt = cmp::min(cnt, self.limit);
-        self.limit -= cnt;
-        self.inner.advance(cnt);
-    }
-}

src/buf/vec_deque.rs

@@ -0,0 +1,22 @@
+use alloc::collections::VecDeque;
+
+use super::Buf;
+
+impl Buf for VecDeque<u8> {
+    fn remaining(&self) -> usize {
+        self.len()
+    }
+
+    fn bytes(&self) -> &[u8] {
+        let (s1, s2) = self.as_slices();
+        if s1.is_empty() {
+            s2
+        } else {
+            s1
+        }
+    }
+
+    fn advance(&mut self, cnt: usize) {
+        self.drain(..cnt);
+    }
+}

src/bytes.rs

@@ -0,0 +1,949 @@
+use core::{cmp, fmt, hash, mem, ptr, slice, usize};
+use core::iter::{FromIterator};
+use core::ops::{Deref, RangeBounds};
+
+use alloc::{vec::Vec, string::String, boxed::Box, borrow::Borrow};
+
+use crate::Buf;
+use crate::buf::IntoIter;
+use crate::debug;
+use crate::loom::sync::atomic::{self, AtomicPtr, AtomicUsize, Ordering};
+
+/// A reference counted contiguous slice of memory.
+///
+/// `Bytes` is an efficient container for storing and operating on contiguous
+/// slices of memory. It is intended for use primarily in networking code, but
+/// could have applications elsewhere as well.
+///
+/// `Bytes` values facilitate zero-copy network programming by allowing multiple
+/// `Bytes` objects to point to the same underlying memory. This is managed by
+/// using a reference count to track when the memory is no longer needed and can
+/// be freed.
+///
+/// ```
+/// use bytes::Bytes;
+///
+/// let mut mem = Bytes::from("Hello world");
+/// let a = mem.slice(0..5);
+///
+/// assert_eq!(a, "Hello");
+///
+/// let b = mem.split_to(6);
+///
+/// assert_eq!(mem, "world");
+/// assert_eq!(b, "Hello ");
+/// ```
+///
+/// # Memory layout
+///
+/// The `Bytes` struct itself is fairly small, limited to 4 `usize` fields used
+/// to track information about which segment of the underlying memory the
+/// `Bytes` handle has access to.
+///
+/// `Bytes` keeps both a pointer to the shared `Arc` containing the full memory
+/// slice and a pointer to the start of the region visible by the handle.
+/// `Bytes` also tracks the length of its view into the memory.
+///
+/// # Sharing
+///
+/// The memory itself is reference counted, and multiple `Bytes` objects may
+/// point to the same region. Each `Bytes` handle point to different sections within
+/// the memory region, and `Bytes` handle may or may not have overlapping views
+/// into the memory.
+///
+///
+/// ```text
+///
+///    Arc ptrs                   +---------+
+///    ________________________ / | Bytes 2 |
+///   /                           +---------+
+///  /          +-----------+     |         |
+/// |_________/ |  Bytes 1  |     |         |
+/// |           +-----------+     |         |
+/// |           |           | ___/ data     | tail
+/// |      data |      tail |/              |
+/// v           v           v               v
+/// +-----+---------------------------------+-----+
+/// | Arc |     |           |               |     |
+/// +-----+---------------------------------+-----+
+/// ```
+pub struct Bytes {
+    ptr: *const u8,
+    len: usize,
+    // inlined "trait object"
+    data: AtomicPtr<()>,
+    vtable: &'static Vtable,
+}
+
+pub(crate) struct Vtable {
+    /// fn(data, ptr, len)
+    pub clone: unsafe fn(&AtomicPtr<()>, *const u8, usize) -> Bytes,
+    /// fn(data, ptr, len)
+    pub drop: unsafe fn(&mut AtomicPtr<()>, *const u8, usize),
+}
+
+impl Bytes {
+    /// Creates a new empty `Bytes`.
+    ///
+    /// This will not allocate and the returned `Bytes` handle will be empty.
+    ///
+    /// # Examples
+    ///
+    /// ```
+    /// use bytes::Bytes;
+    ///
+    /// let b = Bytes::new();
+    /// assert_eq!(&b[..], b"");
+    /// ```
+    #[inline]
+    pub fn new() -> Bytes {
+        Bytes::from_static(b"")
+    }
+
+    /// Creates a new `Bytes` from a static slice.
+    ///
+    /// The returned `Bytes` will point directly to the static slice. There is
+    /// no allocating or copying.
+    ///
+    /// # Examples
+    ///
+    /// ```
+    /// use bytes::Bytes;
+    ///
+    /// let b = Bytes::from_static(b"hello");
+    /// assert_eq!(&b[..], b"hello");
+    /// ```
+    #[inline]
+    #[cfg(not(all(loom, test)))]
+    pub const fn from_static(bytes: &'static [u8]) -> Bytes {
+        Bytes {
+            ptr: bytes.as_ptr(),
+            len: bytes.len(),
+            data: AtomicPtr::new(ptr::null_mut()),
+            vtable: &STATIC_VTABLE,
+        }
+    }
+
+    #[cfg(all(loom, test))]
+    pub fn from_static(bytes: &'static [u8]) -> Bytes {
+        Bytes {
+            ptr: bytes.as_ptr(),
+            len: bytes.len(),
+            data: AtomicPtr::new(ptr::null_mut()),
+            vtable: &STATIC_VTABLE,
+        }
+    }
+
+    /// Returns the number of bytes contained in this `Bytes`.
+    ///
+    /// # Examples
+    ///
+    /// ```
+    /// use bytes::Bytes;
+    ///
+    /// let b = Bytes::from(&b"hello"[..]);
+    /// assert_eq!(b.len(), 5);
+    /// ```
+    #[inline]
+    pub fn len(&self) -> usize {
+        self.len
+    }
+
+    /// Returns true if the `Bytes` has a length of 0.
+    ///
+    /// # Examples
+    ///
+    /// ```
+    /// use bytes::Bytes;
+    ///
+    /// let b = Bytes::new();
+    /// assert!(b.is_empty());
+    /// ```
+    #[inline]
+    pub fn is_empty(&self) -> bool {
+        self.len == 0
+    }
+
+
+    ///Creates `Bytes` instance from slice, by copying it.
+    pub fn copy_from_slice(data: &[u8]) -> Self {
+        data.to_vec().into()
+    }
+
+    /// Returns a slice of self for the provided range.
+    ///
+    /// This will increment the reference count for the underlying memory and
+    /// return a new `Bytes` handle set to the slice.
+    ///
+    /// This operation is `O(1)`.
+    ///
+    /// # Examples
+    ///
+    /// ```
+    /// use bytes::Bytes;
+    ///
+    /// let a = Bytes::from(&b"hello world"[..]);
+    /// let b = a.slice(2..5);
+    ///
+    /// assert_eq!(&b[..], b"llo");
+    /// ```
+    ///
+    /// # Panics
+    ///
+    /// Requires that `begin <= end` and `end <= self.len()`, otherwise slicing
+    /// will panic.
+    pub fn slice(&self, range: impl RangeBounds<usize>) -> Bytes {
+        use core::ops::Bound;
+
+        let len = self.len();
+
+        let begin = match range.start_bound() {
+            Bound::Included(&n) => n,
+            Bound::Excluded(&n) => n + 1,
+            Bound::Unbounded => 0,
+        };
+
+        let end = match range.end_bound() {
+            Bound::Included(&n) => n + 1,
+            Bound::Excluded(&n) => n,
+            Bound::Unbounded => len,
+        };
+
+        assert!(begin <= end);
+        assert!(end <= len);
+
+        if end == begin {
+            return Bytes::new();
+        }
+
+
+        let mut ret = self.clone();
+
+        ret.len = end - begin;
+        ret.ptr = unsafe { ret.ptr.offset(begin as isize) };
+
+        ret
+    }
+
+    /// Returns a slice of self that is equivalent to the given `subset`.
+    ///
+    /// When processing a `Bytes` buffer with other tools, one often gets a
+    /// `&[u8]` which is in fact a slice of the `Bytes`, i.e. a subset of it.
+    /// This function turns that `&[u8]` into another `Bytes`, as if one had
+    /// called `self.slice()` with the offsets that correspond to `subset`.
+    ///
+    /// This operation is `O(1)`.
+    ///
+    /// # Examples
+    ///
+    /// ```
+    /// use bytes::Bytes;
+    ///
+    /// let bytes = Bytes::from(&b"012345678"[..]);
+    /// let as_slice = bytes.as_ref();
+    /// let subset = &as_slice[2..6];
+    /// let subslice = bytes.slice_ref(&subset);
+    /// assert_eq!(&subslice[..], b"2345");
+    /// ```
+    ///
+    /// # Panics
+    ///
+    /// Requires that the given `sub` slice is in fact contained within the
+    /// `Bytes` buffer; otherwise this function will panic.
+    pub fn slice_ref(&self, subset: &[u8]) -> Bytes {
+        let bytes_p = self.as_ptr() as usize;
+        let bytes_len = self.len();
+
+        let sub_p = subset.as_ptr() as usize;
+        let sub_len = subset.len();
+
+        assert!(sub_p >= bytes_p);
+        assert!(sub_p + sub_len <= bytes_p + bytes_len);
+
+        let sub_offset = sub_p - bytes_p;
+
+        self.slice(sub_offset..(sub_offset + sub_len))
+    }
+
+    /// Splits the bytes into two at the given index.
+    ///
+    /// Afterwards `self` contains elements `[0, at)`, and the returned `Bytes`
+    /// contains elements `[at, len)`.
+    ///
+    /// This is an `O(1)` operation that just increases the reference count and
+    /// sets a few indices.
+    ///
+    /// # Examples
+    ///
+    /// ```
+    /// use bytes::Bytes;
+    ///
+    /// let mut a = Bytes::from(&b"hello world"[..]);
+    /// let b = a.split_off(5);
+    ///
+    /// assert_eq!(&a[..], b"hello");
+    /// assert_eq!(&b[..], b" world");
+    /// ```
+    ///
+    /// # Panics
+    ///
+    /// Panics if `at > len`.
+    pub fn split_off(&mut self, at: usize) -> Bytes {
+        assert!(at <= self.len());
+
+        if at == self.len() {
+            return Bytes::new();
+        }
+
+        if at == 0 {
+            return mem::replace(self, Bytes::new());
+        }
+
+        let mut ret = self.clone();
+
+        self.len = at;
+
+        unsafe { ret.inc_start(at) };
+
+        ret
+    }
+
+    /// Splits the bytes into two at the given index.
+    ///
+    /// Afterwards `self` contains elements `[at, len)`, and the returned
+    /// `Bytes` contains elements `[0, at)`.
+    ///
+    /// This is an `O(1)` operation that just increases the reference count and
+    /// sets a few indices.
+    ///
+    /// # Examples
+    ///
+    /// ```
+    /// use bytes::Bytes;
+    ///
+    /// let mut a = Bytes::from(&b"hello world"[..]);
+    /// let b = a.split_to(5);
+    ///
+    /// assert_eq!(&a[..], b" world");
+    /// assert_eq!(&b[..], b"hello");
+    /// ```
+    ///
+    /// # Panics
+    ///
+    /// Panics if `at > len`.
+    pub fn split_to(&mut self, at: usize) -> Bytes {
+        assert!(at <= self.len());
+
+        if at == self.len() {
+            return mem::replace(self, Bytes::new());
+        }
+
+        if at == 0 {
+            return Bytes::new();
+        }
+
+
+        let mut ret = self.clone();
+
+        unsafe { self.inc_start(at) };
+
+        ret.len = at;
+        ret
+    }
+
+    /// Shortens the buffer, keeping the first `len` bytes and dropping the
+    /// rest.
+    ///
+    /// If `len` is greater than the buffer's current length, this has no
+    /// effect.
+    ///
+    /// The [`split_off`] method can emulate `truncate`, but this causes the
+    /// excess bytes to be returned instead of dropped.
+    ///
+    /// # Examples
+    ///
+    /// ```
+    /// use bytes::Bytes;
+    ///
+    /// let mut buf = Bytes::from(&b"hello world"[..]);
+    /// buf.truncate(5);
+    /// assert_eq!(buf, b"hello"[..]);
+    /// ```
+    ///
+    /// [`split_off`]: #method.split_off
+    #[inline]
+    pub fn truncate(&mut self, len: usize) {
+        if len >= self.len {
+            self.len = 0;
+        } else {
+            self.len = len;
+        }
+    }
+
+    /// Clears the buffer, removing all data.
+    ///
+    /// # Examples
+    ///
+    /// ```
+    /// use bytes::Bytes;
+    ///
+    /// let mut buf = Bytes::from(&b"hello world"[..]);
+    /// buf.clear();
+    /// assert!(buf.is_empty());
+    /// ```
+    #[inline]
+    pub fn clear(&mut self) {
+        self.truncate(0);
+    }
+
+    #[inline]
+    pub(crate) unsafe fn with_vtable(ptr: *const u8, len: usize, data: AtomicPtr<()>, vtable: &'static Vtable) -> Bytes {
+        Bytes {
+            ptr,
+            len,
+            data,
+            vtable,
+        }
+    }
+
+    // private
+
+    #[inline]
+    fn as_slice(&self) -> &[u8] {
+        unsafe {
+            slice::from_raw_parts(self.ptr, self.len)
+        }
+    }
+
+    #[inline]
+    unsafe fn inc_start(&mut self, by: usize) {
+        // should already be asserted, but debug assert for tests
+        debug_assert!(self.len >= by);
+        self.len -= by;
+        self.ptr = self.ptr.offset(by as isize);
+    }
+}
+
+// Vtable must enforce this behavior
+unsafe impl Send for Bytes {}
+unsafe impl Sync for Bytes {}
+
+impl Drop for Bytes {
+    #[inline]
+    fn drop(&mut self) {
+        unsafe {
+            (self.vtable.drop)(&mut self.data, self.ptr, self.len)
+        }
+    }
+}
+
+impl Clone for Bytes {
+    #[inline]
+    fn clone(&self) -> Bytes {
+        unsafe {
+            (self.vtable.clone)(&self.data, self.ptr, self.len)
+        }
+    }
+}
+
+impl fmt::Debug for Bytes {
+    fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
+        fmt::Debug::fmt(&debug::BsDebug(&self.as_slice()), f)
+    }
+}
+
+impl Buf for Bytes {
+    #[inline]
+    fn remaining(&self) -> usize {
+        self.len()
+    }
+
+    #[inline]
+    fn bytes(&self) -> &[u8] {
+        self.as_slice()
+    }
+
+    #[inline]
+    fn advance(&mut self, cnt: usize) {
+        assert!(cnt <= self.len(), "cannot advance past `remaining`");
+        unsafe {
+            self.inc_start(cnt);
+        }
+    }
+
+    fn to_bytes(&mut self) -> crate::Bytes {
+        core::mem::replace(self, Bytes::new())
+    }
+}
+
+impl Deref for Bytes {
+    type Target = [u8];
+
+    #[inline]
+    fn deref(&self) -> &[u8] {
+        self.as_slice()
+    }
+}
+
+impl AsRef<[u8]> for Bytes {
+    #[inline]
+    fn as_ref(&self) -> &[u8] {
+        self.as_slice()
+    }
+}
+
+impl hash::Hash for Bytes {
+    fn hash<H>(&self, state: &mut H) where H: hash::Hasher {
+        self.as_slice().hash(state);
+    }
+}
+
+impl Borrow<[u8]> for Bytes {
+    fn borrow(&self) -> &[u8] {
+        self.as_slice()
+    }
+}
+
+impl IntoIterator for Bytes {
+    type Item = u8;
+    type IntoIter = IntoIter<Bytes>;
+
+    fn into_iter(self) -> Self::IntoIter {
+        IntoIter::new(self)
+    }
+}
+
+impl<'a> IntoIterator for &'a Bytes {
+    type Item = &'a u8;
+    type IntoIter = core::slice::Iter<'a, u8>;
+
+    fn into_iter(self) -> Self::IntoIter {
+        self.as_slice().into_iter()
+    }
+}
+
+impl FromIterator<u8> for Bytes {
+    fn from_iter<T: IntoIterator<Item = u8>>(into_iter: T) -> Self {
+        Vec::from_iter(into_iter).into()
+    }
+}
+
+// impl Eq
+
+impl PartialEq for Bytes {
+    fn eq(&self, other: &Bytes) -> bool {
+        self.as_slice() == other.as_slice()
+    }
+}
+
+impl PartialOrd for Bytes {
+    fn partial_cmp(&self, other: &Bytes) -> Option<cmp::Ordering> {
+        self.as_slice().partial_cmp(other.as_slice())
+    }
+}
+
+impl Ord for Bytes {
+    fn cmp(&self, other: &Bytes) -> cmp::Ordering {
+        self.as_slice().cmp(other.as_slice())
+    }
+}
+
+impl Eq for Bytes {}
+
+impl PartialEq<[u8]> for Bytes {
+    fn eq(&self, other: &[u8]) -> bool {
+        self.as_slice() == other
+    }
+}
+
+impl PartialOrd<[u8]> for Bytes {
+    fn partial_cmp(&self, other: &[u8]) -> Option<cmp::Ordering> {
+        self.as_slice().partial_cmp(other)
+    }
+}
+
+impl PartialEq<Bytes> for [u8] {
+    fn eq(&self, other: &Bytes) -> bool {
+        *other == *self
+    }
+}
+
+impl PartialOrd<Bytes> for [u8] {
+    fn partial_cmp(&self, other: &Bytes) -> Option<cmp::Ordering> {
+        other.partial_cmp(self)
+    }
+}
+
+impl PartialEq<str> for Bytes {
+    fn eq(&self, other: &str) -> bool {
+        self.as_slice() == other.as_bytes()
+    }
+}
+
+impl PartialOrd<str> for Bytes {
+    fn partial_cmp(&self, other: &str) -> Option<cmp::Ordering> {
+        self.as_slice().partial_cmp(other.as_bytes())
+    }
+}
+
+impl PartialEq<Bytes> for str {
+    fn eq(&self, other: &Bytes) -> bool {
+        *other == *self
+    }
+}
+
+impl PartialOrd<Bytes> for str {
+    fn partial_cmp(&self, other: &Bytes) -> Option<cmp::Ordering> {
+        other.partial_cmp(self)
+    }
+}
+
+impl PartialEq<Vec<u8>> for Bytes {
+    fn eq(&self, other: &Vec<u8>) -> bool {
+        *self == &other[..]
+    }
+}
+
+impl PartialOrd<Vec<u8>> for Bytes {
+    fn partial_cmp(&self, other: &Vec<u8>) -> Option<cmp::Ordering> {
+        self.as_slice().partial_cmp(&other[..])
+    }
+}
+
+impl PartialEq<Bytes> for Vec<u8> {
+    fn eq(&self, other: &Bytes) -> bool {
+        *other == *self
+    }
+}
+
+impl PartialOrd<Bytes> for Vec<u8> {
+    fn partial_cmp(&self, other: &Bytes) -> Option<cmp::Ordering> {
+        other.partial_cmp(self)
+    }
+}
+
+impl PartialEq<String> for Bytes {
+    fn eq(&self, other: &String) -> bool {
+        *self == &other[..]
+    }
+}
+
+impl PartialOrd<String> for Bytes {
+    fn partial_cmp(&self, other: &String) -> Option<cmp::Ordering> {
+        self.as_slice().partial_cmp(other.as_bytes())
+    }
+}
+
+impl PartialEq<Bytes> for String {
+    fn eq(&self, other: &Bytes) -> bool {
+        *other == *self
+    }
+}
+
+impl PartialOrd<Bytes> for String {
+    fn partial_cmp(&self, other: &Bytes) -> Option<cmp::Ordering> {
+        other.partial_cmp(self)
+    }
+}
+
+impl PartialEq<Bytes> for &[u8] {
+    fn eq(&self, other: &Bytes) -> bool {
+        *other == *self
+    }
+}
+
+impl PartialOrd<Bytes> for &[u8] {
+    fn partial_cmp(&self, other: &Bytes) -> Option<cmp::Ordering> {
+        other.partial_cmp(self)
+    }
+}
+
+impl PartialEq<Bytes> for &str {
+    fn eq(&self, other: &Bytes) -> bool {
+        *other == *self
+    }
+}
+
+impl PartialOrd<Bytes> for &str {
+    fn partial_cmp(&self, other: &Bytes) -> Option<cmp::Ordering> {
+        other.partial_cmp(self)
+    }
+}
+
+impl<'a, T: ?Sized> PartialEq<&'a T> for Bytes
+    where Bytes: PartialEq<T>
+{
+    fn eq(&self, other: &&'a T) -> bool {
+        *self == **other
+    }
+}
+
+impl<'a, T: ?Sized> PartialOrd<&'a T> for Bytes
+    where Bytes: PartialOrd<T>
+{
+    fn partial_cmp(&self, other: &&'a T) -> Option<cmp::Ordering> {
+        self.partial_cmp(&**other)
+    }
+}
+
+// impl From
+
+impl Default for Bytes {
+    #[inline]
+    fn default() -> Bytes {
+        Bytes::new()
+    }
+}
+
+impl From<&'static [u8]> for Bytes {
+    fn from(slice: &'static [u8]) -> Bytes {
+        Bytes::from_static(slice)
+    }
+}
+
+impl From<&'static str> for Bytes {
+    fn from(slice: &'static str) -> Bytes {
+        Bytes::from_static(slice.as_bytes())
+    }
+}
+
+impl From<Vec<u8>> for Bytes {
+    fn from(vec: Vec<u8>) -> Bytes {
+        let slice = vec.into_boxed_slice();
+        let len = slice.len();
+        let ptr = slice.as_ptr();
+        drop(Box::into_raw(slice));
+
+        let data = ptr as usize | KIND_VEC;
+        Bytes {
+            ptr,
+            len,
+            data: AtomicPtr::new(data as *mut _),
+            vtable: &SHARED_VTABLE,
+        }
+    }
+}
+
+impl From<String> for Bytes {
+    fn from(s: String) -> Bytes {
+        Bytes::from(s.into_bytes())
+    }
+}
+
+// ===== impl Vtable =====
+
+impl fmt::Debug for Vtable {
+    fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
+        f.debug_struct("Vtable")
+            .field("clone", &(self.clone as *const ()))
+            .field("drop", &(self.drop as *const ()))
+            .finish()
+    }
+}
+
+// ===== impl StaticVtable =====
+
+const STATIC_VTABLE: Vtable = Vtable {
+    clone: static_clone,
+    drop: static_drop,
+};
+
+unsafe fn static_clone(_: &AtomicPtr<()>, ptr: *const u8, len: usize) -> Bytes {
+    let slice = slice::from_raw_parts(ptr, len);
+    Bytes::from_static(slice)
+}
+
+unsafe fn static_drop(_: &mut AtomicPtr<()>, _: *const u8, _: usize) {
+    // nothing to drop for &'static [u8]
+}
+
+// ===== impl SharedVtable =====
+
+struct Shared {
+    // holds vec for drop, but otherwise doesnt access it
+    _vec: Vec<u8>,
+    ref_cnt: AtomicUsize,
+}
+
+static SHARED_VTABLE: Vtable = Vtable {
+    clone: shared_clone,
+    drop: shared_drop,
+};
+
+const KIND_ARC: usize = 0b0;
+const KIND_VEC: usize = 0b1;
+const KIND_MASK: usize = 0b1;
+
+unsafe fn shared_clone(data: &AtomicPtr<()>, ptr: *const u8, len: usize) -> Bytes {
+    let shared = data.load(Ordering::Acquire);
+    let kind = shared as usize & KIND_MASK;
+
+    if kind == KIND_ARC {
+        shallow_clone_arc(shared as _, ptr, len)
+    } else {
+        debug_assert_eq!(kind, KIND_VEC);
+        shallow_clone_vec(data, shared, ptr, len)
+    }
+}
+
+unsafe fn shared_drop(data: &mut AtomicPtr<()>, ptr: *const u8, len: usize) {
+    let shared = *data.get_mut();
+    let kind = shared as usize & KIND_MASK;
+
+
+    if kind == KIND_ARC {
+        release_shared(shared as *mut Shared);
+    } else {
+        debug_assert_eq!(kind, KIND_VEC);
+
+        drop(rebuild_vec(shared, ptr, len));
+    }
+}
+
+unsafe fn rebuild_vec(shared: *const (), offset: *const u8, len: usize) -> Vec<u8> {
+    debug_assert_eq!(shared as usize & KIND_MASK, KIND_VEC);
+
+    let buf = (shared as usize & !KIND_MASK) as *mut u8;
+    let cap = (offset as usize - buf as usize) + len;
+    Vec::from_raw_parts(buf, cap, cap)
+}
+
+unsafe fn shallow_clone_arc(shared: *mut Shared, ptr: *const u8, len: usize) -> Bytes {
+    let old_size = (*shared).ref_cnt.fetch_add(1, Ordering::Relaxed);
+
+    if old_size > usize::MAX >> 1 {
+        crate::abort();
+    }
+
+    Bytes {
+        ptr,
+        len,
+        data: AtomicPtr::new(shared as _),
+        vtable: &SHARED_VTABLE,
+    }
+}
+
+#[cold]
+unsafe fn shallow_clone_vec(atom: &AtomicPtr<()>, ptr: *const (), offset: *const u8, len: usize) -> Bytes {
+    // If  the buffer is still tracked in a `Vec<u8>`. It is time to
+    // promote the vec to an `Arc`. This could potentially be called
+    // concurrently, so some care must be taken.
+
+    debug_assert_eq!(ptr as usize & KIND_MASK, KIND_VEC);
+
+    // First, allocate a new `Shared` instance containing the
+    // `Vec` fields. It's important to note that `ptr`, `len`,
+    // and `cap` cannot be mutated without having `&mut self`.
+    // This means that these fields will not be concurrently
+    // updated and since the buffer hasn't been promoted to an
+    // `Arc`, those three fields still are the components of the
+    // vector.
+    let vec = rebuild_vec(ptr as *const (), offset, len);
+    let shared = Box::new(Shared {
+        _vec: vec,
+        // Initialize refcount to 2. One for this reference, and one
+        // for the new clone that will be returned from
+        // `shallow_clone`.
+        ref_cnt: AtomicUsize::new(2),
+    });
+
+    let shared = Box::into_raw(shared);
+
+    // The pointer should be aligned, so this assert should
+    // always succeed.
+    debug_assert!(0 == (shared as usize & KIND_MASK));
+
+    // Try compare & swapping the pointer into the `arc` field.
+    // `Release` is used synchronize with other threads that
+    // will load the `arc` field.
+    //
+    // If the `compare_and_swap` fails, then the thread lost the
+    // race to promote the buffer to shared. The `Acquire`
+    // ordering will synchronize with the `compare_and_swap`
+    // that happened in the other thread and the `Shared`
+    // pointed to by `actual` will be visible.
+    let actual = atom.compare_and_swap(ptr as _, shared as _, Ordering::AcqRel);
+
+    if actual as usize == ptr as usize {
+        // The upgrade was successful, the new handle can be
+        // returned.
+        return Bytes {
+            ptr: offset,
+            len,
+            data: AtomicPtr::new(shared as _),
+            vtable: &SHARED_VTABLE,
+        };
+    }
+
+    // The upgrade failed, a concurrent clone happened. Release
+    // the allocation that was made in this thread, it will not
+    // be needed.
+    let shared = Box::from_raw(shared);
+    mem::forget(*shared);
+
+    // Buffer already promoted to shared storage, so increment ref
+    // count.
+    shallow_clone_arc(actual as _, offset, len)
+}
+
+unsafe fn release_shared(ptr: *mut Shared) {
+    // `Shared` storage... follow the drop steps from Arc.
+    if (*ptr).ref_cnt.fetch_sub(1, Ordering::Release) != 1 {
+        return;
+    }
+
+    // This fence is needed to prevent reordering of use of the data and
+    // deletion of the data.  Because it is marked `Release`, the decreasing
+    // of the reference count synchronizes with this `Acquire` fence. This
+    // means that use of the data happens before decreasing the reference
+    // count, which happens before this fence, which happens before the
+    // deletion of the data.
+    //
+    // As explained in the [Boost documentation][1],
+    //
+    // > It is important to enforce any possible access to the object in one
+    // > thread (through an existing reference) to *happen before* deleting
+    // > the object in a different thread. This is achieved by a "release"
+    // > operation after dropping a reference (any access to the object
+    // > through this reference must obviously happened before), and an
+    // > "acquire" operation before deleting the object.
+    //
+    // [1]: (www.boost.org/doc/libs/1_55_0/doc/html/atomic/usage_examples.html)
+    atomic::fence(Ordering::Acquire);
+
+    // Drop the data
+    Box::from_raw(ptr);
+}
+
+// fuzz tests
+#[cfg(all(test, loom))]
+mod fuzz {
+    use std::sync::Arc;
+    use loom::thread;
+
+    use super::Bytes;
+    #[test]
+    fn bytes_cloning_vec() {
+        loom::model(|| {
+            let a = Bytes::from(b"abcdefgh".to_vec());
+            let addr = a.as_ptr() as usize;
+
+            // test the Bytes::clone is Sync by putting it in an Arc
+            let a1 = Arc::new(a);
+            let a2 = a1.clone();
+
+            let t1 = thread::spawn(move || {
+                let b: Bytes = (*a1).clone();
+                assert_eq!(b.as_ptr() as usize, addr);
+            });
+
+            let t2 = thread::spawn(move || {
+                let b: Bytes = (*a2).clone();
+                assert_eq!(b.as_ptr() as usize, addr);
+            });
+
+            t1.join().unwrap();
+            t2.join().unwrap();
+        });
+    }
+}

src/debug.rs

@@ -0,0 +1,40 @@
+use core::fmt;
+
+/// Alternative implementation of `fmt::Debug` for byte slice.
+///
+/// Standard `Debug` implementation for `[u8]` is comma separated
+/// list of numbers. Since large amount of byte strings are in fact
+/// ASCII strings or contain a lot of ASCII strings (e. g. HTTP),
+/// it is convenient to print strings as ASCII when possible.
+///
+/// This struct wraps `&[u8]` just to override `fmt::Debug`.
+///
+/// `BsDebug` is not a part of public API of bytes crate.
+pub struct BsDebug<'a>(pub &'a [u8]);
+
+impl fmt::Debug for BsDebug<'_> {
+    fn fmt(&self, fmt: &mut fmt::Formatter<'_>) -> Result<(), fmt::Error> {
+        write!(fmt, "b\"")?;
+        for &c in self.0 {
+            // https://doc.rust-lang.org/reference.html#byte-escapes
+            if c == b'\n' {
+                write!(fmt, "\\n")?;
+            } else if c == b'\r' {
+                write!(fmt, "\\r")?;
+            } else if c == b'\t' {
+                write!(fmt, "\\t")?;
+            } else if c == b'\\' || c == b'"' {
+                write!(fmt, "\\{}", c as char)?;
+            } else if c == b'\0' {
+                write!(fmt, "\\0")?;
+            // ASCII printable
+            } else if c >= 0x20 && c < 0x7f {
+                write!(fmt, "{}", c as char)?;
+            } else {
+                write!(fmt, "\\x{:02x}", c)?;
+            }
+        }
+        write!(fmt, "\"")?;
+        Ok(())
+    }
+}

src/hex.rs

@@ -0,0 +1,37 @@
+use crate::{Bytes, BytesMut};
+use core::fmt::{Formatter, LowerHex, Result, UpperHex};
+
+struct BytesRef<'a>(&'a [u8]);
+
+impl<'a> LowerHex for BytesRef<'a> {
+    fn fmt(&self, f: &mut Formatter<'_>) -> Result {
+        for b in self.0 {
+            write!(f, "{:02x}", b)?;
+        }
+        Ok(())
+    }
+}
+
+impl<'a> UpperHex for BytesRef<'a> {
+    fn fmt(&self, f: &mut Formatter<'_>) -> Result {
+        for b in self.0 {
+            write!(f, "{:02X}", b)?;
+        }
+        Ok(())
+    }
+}
+
+macro_rules! hex_impl {
+    ($tr:ident, $ty:ty) => {
+        impl $tr for $ty {
+            fn fmt(&self, f: &mut Formatter<'_>) -> Result {
+                $tr::fmt(&BytesRef(self.as_ref()), f)
+            }
+        }
+    };
+}
+
+hex_impl!(LowerHex, Bytes);
+hex_impl!(LowerHex, BytesMut);
+hex_impl!(UpperHex, Bytes);
+hex_impl!(UpperHex, BytesMut);

src/lib.rs

@@ -1,54 +1,118 @@
-#![crate_name = "bytes"]
-#![deny(warnings)]
+#![deny(warnings, missing_docs, missing_debug_implementations, rust_2018_idioms)]
+#![doc(html_root_url = "https://docs.rs/bytes/0.5.2")]
+#![no_std]
+
+//! Provides abstractions for working with bytes.
+//!
+//! The `bytes` crate provides an efficient byte buffer structure
+//! ([`Bytes`](struct.Bytes.html)) and traits for working with buffer
+//! implementations ([`Buf`], [`BufMut`]).
+//!
+//! [`Buf`]: trait.Buf.html
+//! [`BufMut`]: trait.BufMut.html
+//!
+//! # `Bytes`
+//!
+//! `Bytes` is an efficient container for storing and operating on contiguous
+//! slices of memory. It is intended for use primarily in networking code, but
+//! could have applications elsewhere as well.
+//!
+//! `Bytes` values facilitate zero-copy network programming by allowing multiple
+//! `Bytes` objects to point to the same underlying memory. This is managed by
+//! using a reference count to track when the memory is no longer needed and can
+//! be freed.
+//!
+//! A `Bytes` handle can be created directly from an existing byte store (such as `&[u8]`
+//! or `Vec<u8>`), but usually a `BytesMut` is used first and written to. For
+//! example:
+//!
+//! ```rust
+//! use bytes::{BytesMut, BufMut};
+//!
+//! let mut buf = BytesMut::with_capacity(1024);
+//! buf.put(&b"hello world"[..]);
+//! buf.put_u16(1234);
+//!
+//! let a = buf.split();
+//! assert_eq!(a, b"hello world\x04\xD2"[..]);
+//!
+//! buf.put(&b"goodbye world"[..]);
+//!
+//! let b = buf.split();
+//! assert_eq!(b, b"goodbye world"[..]);
+//!
+//! assert_eq!(buf.capacity(), 998);
+//! ```
+//!
+//! In the above example, only a single buffer of 1024 is allocated. The handles
+//! `a` and `b` will share the underlying buffer and maintain indices tracking
+//! the view into the buffer represented by the handle.
+//!
+//! See the [struct docs] for more details.
+//!
+//! [struct docs]: struct.Bytes.html
+//!
+//! # `Buf`, `BufMut`
+//!
+//! These two traits provide read and write access to buffers. The underlying
+//! storage may or may not be in contiguous memory. For example, `Bytes` is a
+//! buffer that guarantees contiguous memory, but a [rope] stores the bytes in
+//! disjoint chunks. `Buf` and `BufMut` maintain cursors tracking the current
+//! position in the underlying byte storage. When bytes are read or written, the
+//! cursor is advanced.
+//!
+//! [rope]: https://en.wikipedia.org/wiki/Rope_(data_structure)
+//!
+//! ## Relation with `Read` and `Write`
+//!
+//! At first glance, it may seem that `Buf` and `BufMut` overlap in
+//! functionality with `std::io::Read` and `std::io::Write`. However, they
+//! serve different purposes. A buffer is the value that is provided as an
+//! argument to `Read::read` and `Write::write`. `Read` and `Write` may then
+//! perform a syscall, which has the potential of failing. Operations on `Buf`
+//! and `BufMut` are infallible.
+
+
+extern crate alloc;
+
+#[cfg(feature = "std")]
+extern crate std;
 
-pub mod alloc;
 pub mod buf;
-pub mod str;
-
-pub use buf::{
+pub use crate::buf::{
     Buf,
-    BufExt,
-    MutBuf,
-    MutBufExt,
-    ByteBuf,
-    MutByteBuf,
-    RingBuf,
-    ROByteBuf,
-    SliceBuf,
-    MutSliceBuf,
-    Source,
-    Sink,
-    Take,
-};
-pub use str::{
-    ByteStr,
-    Bytes,
-    Rope,
-    RopeBuf,
-    SeqByteStr,
-    SmallByteStr,
-    SmallByteStrBuf,
-    ToBytes,
+    BufMut,
 };
 
-use std::u32;
+mod bytes_mut;
+mod bytes;
+mod debug;
+mod hex;
+mod loom;
+pub use crate::bytes_mut::BytesMut;
+pub use crate::bytes::Bytes;
 
-pub mod traits {
-    //! All traits are re-exported here to allow glob imports.
-    pub use {Buf, BufExt, MutBuf, MutBufExt, ByteStr, ToBytes};
-}
-
-const MAX_CAPACITY: usize = u32::MAX as usize;
-
-
-/*
- *
- * ===== BufError  =====
- *
- */
-
-#[derive(Copy, Clone, Debug)]
-pub enum BufError {
-    Underflow,
-    Overflow,
+// Optional Serde support
+#[cfg(feature = "serde")]
+mod serde;
+
+#[inline(never)]
+#[cold]
+fn abort() -> ! {
+    #[cfg(feature = "std")]
+    {
+        std::process::abort();
+    }
+
+    #[cfg(not(feature = "std"))]
+    {
+        struct Abort;
+        impl Drop for Abort {
+            fn drop(&mut self) {
+                panic!();
+            }
+        }
+        let _a = Abort;
+        panic!("abort");
+    }
 }

src/loom.rs

@@ -0,0 +1,9 @@
+#[cfg(not(all(test, loom)))]
+pub(crate) mod sync {
+    pub(crate) mod atomic {
+        pub(crate) use core::sync::atomic::{fence, AtomicPtr, AtomicUsize, Ordering};
+    }
+}
+
+#[cfg(all(test, loom))]
+pub(crate) use ::loom::sync;

src/serde.rs

@@ -0,0 +1,82 @@
+use alloc::string::String;
+use alloc::vec::Vec;
+use core::{cmp, fmt};
+use serde::{Serialize, Serializer, Deserialize, Deserializer, de};
+use super::{Bytes, BytesMut};
+
+macro_rules! serde_impl {
+    ($ty:ident, $visitor_ty:ident, $from_slice:ident, $from_vec:ident) => (
+        impl Serialize for $ty {
+            #[inline]
+            fn serialize<S>(&self, serializer: S) -> Result<S::Ok, S::Error>
+                where S: Serializer
+            {
+                serializer.serialize_bytes(&self)
+            }
+        }
+
+        struct $visitor_ty;
+
+        impl<'de> de::Visitor<'de> for $visitor_ty {
+            type Value = $ty;
+
+            fn expecting(&self, formatter: &mut fmt::Formatter<'_>) -> fmt::Result {
+                formatter.write_str("byte array")
+            }
+
+            #[inline]
+            fn visit_seq<V>(self, mut seq: V) -> Result<Self::Value, V::Error>
+                where V: de::SeqAccess<'de>
+            {
+                let len = cmp::min(seq.size_hint().unwrap_or(0), 4096);
+                let mut values: Vec<u8> = Vec::with_capacity(len);
+
+                while let Some(value) = seq.next_element()? {
+                    values.push(value);
+                }
+
+                Ok($ty::$from_vec(values))
+            }
+
+            #[inline]
+            fn visit_bytes<E>(self, v: &[u8]) -> Result<Self::Value, E>
+                where E: de::Error
+            {
+                Ok($ty::$from_slice(v))
+            }
+
+            #[inline]
+            fn visit_byte_buf<E>(self, v: Vec<u8>) -> Result<Self::Value, E>
+                where E: de::Error
+            {
+                Ok($ty::$from_vec(v))
+            }
+
+            #[inline]
+            fn visit_str<E>(self, v: &str) -> Result<Self::Value, E>
+                where E: de::Error
+            {
+                Ok($ty::$from_slice(v.as_bytes()))
+            }
+
+            #[inline]
+            fn visit_string<E>(self, v: String) -> Result<Self::Value, E>
+                where E: de::Error
+            {
+                Ok($ty::$from_vec(v.into_bytes()))
+            }
+        }
+
+        impl<'de> Deserialize<'de> for $ty {
+            #[inline]
+            fn deserialize<D>(deserializer: D) -> Result<$ty, D::Error>
+                where D: Deserializer<'de>
+            {
+                deserializer.deserialize_byte_buf($visitor_ty)
+            }
+        }
+    );
+}
+
+serde_impl!(Bytes, BytesVisitor, copy_from_slice, from);
+serde_impl!(BytesMut, BytesMutVisitor, from, from_vec);

src/str/bytes.rs

@@ -1,310 +0,0 @@
-use {ByteBuf, MutBuf, SmallByteStr, Source, BufError};
-use traits::{Buf, ByteStr, ToBytes};
-use std::{cmp, fmt, mem, ops, ptr};
-use std::any::{Any, TypeId};
-
-const INLINE: usize = 1;
-
-/// A specialized `ByteStr` box.
-pub struct Bytes {
-    vtable: usize,
-    data: *mut (),
-}
-
-impl Bytes {
-    pub fn from_slice(bytes: &[u8]) -> Bytes {
-        SmallByteStr::from_slice(bytes)
-            .map(|small| Bytes::of(small))
-            .unwrap_or_else(|| ByteBuf::from_slice(bytes).to_bytes())
-    }
-
-    pub fn of<B: ByteStr>(bytes: B) -> Bytes {
-        unsafe {
-            if inline::<B>() {
-                let 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+'static>;
-
-    fn buf(&self) -> Box<Buf+'static> {
-        self.obj().buf()
-    }
-
-    fn concat<B: ByteStr>(&self, other: &B) -> Bytes {
-        self.obj().concat(&Bytes::of(other.clone()))
-    }
-
-    fn len(&self) -> usize {
-        self.obj().len()
-    }
-
-    fn slice(&self, begin: usize, end: usize) -> Bytes {
-        self.obj().slice(begin, end)
-    }
-
-    fn split_at(&self, mid: usize) -> (Bytes, Bytes) {
-        self.obj().split_at(mid)
-    }
-}
-
-impl ToBytes for Bytes {
-    fn to_bytes(self) -> Bytes {
-        self
-    }
-}
-
-impl ops::Index<usize> for Bytes {
-    type Output = u8;
-
-    fn index(&self, index: usize) -> &u8 {
-        self.obj().index(index)
-    }
-}
-
-impl fmt::Debug for Bytes {
-    fn fmt(&self, fmt: &mut fmt::Formatter) -> fmt::Result {
-        super::debug(self, "Bytes", fmt)
-    }
-}
-
-impl Clone for Bytes {
-    fn clone(&self) -> Bytes {
-        self.obj().clone()
-    }
-}
-
-impl Drop for Bytes {
-    fn drop(&mut self) {
-        unsafe {
-            if self.is_inline() {
-                let obj = self.obj_mut();
-                obj.drop();
-            } else {
-                let _: Box<ByteStrPriv> =
-                    mem::transmute(self.obj());
-            }
-        }
-    }
-}
-
-unsafe impl Send for Bytes { }
-unsafe impl Sync for Bytes { }
-
-impl<'a> Source for &'a Bytes {
-    type Error = BufError;
-
-    fn fill<B: MutBuf>(self, dst: &mut B) -> Result<usize, BufError> {
-        let mut src = ByteStr::buf(self);
-        let mut res = 0;
-
-        while src.has_remaining() && dst.has_remaining() {
-            let l;
-
-            unsafe {
-                let s = src.bytes();
-                let d = dst.mut_bytes();
-                l = cmp::min(s.len(), d.len());
-
-                ptr::copy_nonoverlapping(
-                    s.as_ptr(),
-                    d.as_mut_ptr(),
-                    l);
-            }
-
-            src.advance(l);
-            unsafe { dst.advance(l); }
-
-            res += l;
-        }
-
-        Ok(res)
-    }
-}
-
-trait ByteStrPriv {
-
-    fn buf(&self) -> Box<Buf+'static>;
-
-    fn clone(&self) -> Bytes;
-
-    fn concat(&self, other: &Bytes) -> Bytes;
-
-    fn drop(&mut self);
-
-    fn get_type_id(&self) -> TypeId;
-
-    fn index(&self, index: usize) -> &u8;
-
-    fn len(&self) -> usize;
-
-    fn slice(&self, begin: usize, end: usize) -> Bytes;
-
-    fn split_at(&self, mid: usize) -> (Bytes, Bytes);
-}
-
-impl<B: ByteStr> ByteStrPriv for B {
-
-    fn buf(&self) -> Box<Buf+'static> {
-        Box::new(self.buf())
-    }
-
-    fn clone(&self) -> Bytes {
-        Bytes::of(self.clone())
-    }
-
-    fn concat(&self, other: &Bytes) -> Bytes {
-        self.concat(other)
-    }
-
-    fn drop(&mut self) {
-        unsafe {
-            ptr::read(mem::transmute(self))
-        }
-    }
-
-    fn get_type_id(&self) -> TypeId {
-        TypeId::of::<B>()
-    }
-
-    fn index(&self, index: usize) -> &u8 {
-        ops::Index::index(self, index)
-    }
-
-    fn len(&self) -> usize {
-        self.len()
-    }
-
-    fn slice(&self, begin: usize, end: usize) -> Bytes {
-        self.slice(begin, end)
-    }
-
-    fn split_at(&self, mid: usize) -> (Bytes, Bytes) {
-        self.split_at(mid)
-    }
-}
-
-// TODO: Figure out how to not depend on the memory layout of trait objects
-// Blocked: rust-lang/rust#24050
-#[repr(C)]
-struct TraitObject {
-    data: *mut (),
-    vtable: *mut (),
-}
-
-#[test]
-pub fn test_size_of() {
-    // TODO: One day, there shouldn't be a drop flag
-    let ptr_size = mem::size_of::<usize>();
-    let expect = ptr_size * 3;
-
-    assert_eq!(expect, mem::size_of::<Bytes>());
-    assert_eq!(expect + ptr_size, mem::size_of::<Option<Bytes>>());
-}

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+'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,585 +0,0 @@
-use {Bytes, ByteBuf, Source, BufError};
-use traits::{Buf, ByteStr, MutBuf, MutBufExt, ToBytes};
-use std::{cmp, mem, ops};
-use std::sync::Arc;
-
-// The implementation is mostly a port of the implementation found in the Java
-// protobuf lib.
-
-const CONCAT_BY_COPY_LEN: usize = 128;
-const MAX_DEPTH: usize = 47;
-
-// Used to decide when to rebalance the tree.
-static MIN_LENGTH_BY_DEPTH: [usize; MAX_DEPTH] = [
-              1,              2,              3,              5,              8,
-             13,             21,             34,             55,             89,
-            144,            233,            377,            610,            987,
-          1_597,          2_584,          4_181,          6_765,         10_946,
-         17_711,         28_657,         46_368,         75_025,        121_393,
-        196_418,        317_811,        514_229,        832_040,      1_346_269,
-      2_178_309,      3_524_578,      5_702_887,      9_227_465,     14_930_352,
-     24_157_817,     39_088_169,     63_245_986,    102_334_155,    165_580_141,
-    267_914_296,    433_494_437,    701_408_733,  1_134_903_170,  1_836_311_903,
-  2_971_215_073,  4_294_967_295];
-
-/// An immutable sequence of bytes formed by concatenation of other `ByteStr`
-/// values, without copying the data in the pieces. The concatenation is
-/// represented as a tree whose leaf nodes are each a `Bytes` value.
-///
-/// Most of the operation here is inspired by the now-famous paper [Ropes: an
-/// Alternative to Strings. hans-j. boehm, russ atkinson and michael
-/// plass](http://www.cs.rit.edu/usr/local/pub/jeh/courses/QUARTERS/FP/Labs/CedarRope/rope-paper.pdf).
-///
-/// Fundamentally the Rope algorithm represents the collection of pieces as a
-/// binary tree. BAP95 uses a Fibonacci bound relating depth to a minimum
-/// sequence length, sequences that are too short relative to their depth cause
-/// a tree rebalance.  More precisely, a tree of depth d is "balanced" in the
-/// terminology of BAP95 if its length is at least F(d+2), where F(n) is the
-/// n-the Fibonacci number. Thus for depths 0, 1, 2, 3, 4, 5,... we have
-/// minimum lengths 1, 2, 3, 5, 8, 13,...
-pub struct Rope {
-    inner: Arc<RopeInner>,
-}
-
-impl Rope {
-    pub fn from_slice(bytes: &[u8]) -> Rope {
-        Rope::new(Bytes::from_slice(bytes), Bytes::empty())
-    }
-
-    /// Returns a Rope consisting of the supplied Bytes as a single segment.
-    pub fn of<B: ByteStr + 'static>(bytes: B) -> Rope {
-        let bytes = Bytes::of(bytes);
-
-        match bytes.try_unwrap() {
-            Ok(rope) => rope,
-            Err(bytes) => Rope::new(bytes, Bytes::empty()),
-        }
-    }
-
-    fn new(left: Bytes, right: Bytes) -> Rope {
-        Rope { inner: Arc::new(RopeInner::new(left, right)) }
-    }
-
-    pub fn len(&self) -> usize {
-        self.inner.len as usize
-    }
-
-    pub fn is_empty(&self) -> bool {
-        self.len() == 0
-    }
-
-    /*
-     *
-     * ===== Priv fns =====
-     *
-     */
-
-    fn depth(&self) -> u16 {
-        self.inner.depth
-    }
-
-    fn left(&self) -> &Bytes {
-        &self.inner.left
-    }
-
-    fn right(&self) -> &Bytes {
-        &self.inner.right
-    }
-
-    fn pieces<'a>(&'a self) -> PieceIter<'a> {
-        PieceIter::new(&self.inner)
-    }
-}
-
-impl ByteStr for Rope {
-    type Buf = RopeBuf;
-
-    fn buf(&self) -> RopeBuf {
-        RopeBuf::new(self.clone())
-    }
-
-    fn concat<B: ByteStr+'static>(&self, other: &B) -> Bytes {
-        let left = Bytes::of(self.clone());
-        let right = Bytes::of(other.clone());
-        Bytes::of(concat(left, right))
-    }
-
-    fn len(&self) -> usize {
-        Rope::len(self)
-    }
-
-    fn slice(&self, begin: usize, end: usize) -> Bytes {
-        if begin >= end || begin >= self.len() {
-            return Bytes::empty()
-        }
-
-        let end = cmp::min(end, self.len());
-        let len = end - begin;
-
-        // Empty slice
-        if len == 0 {
-            return Bytes::empty();
-        }
-
-        // Full rope
-        if len == self.len() {
-            return Bytes::of(self.clone());
-        }
-
-        // == Proper substring ==
-
-        let left_len = self.inner.left.len();
-
-        if end <= left_len {
-            // Slice on the left
-            return self.inner.left.slice(begin, end);
-        }
-
-        if begin >= left_len {
-            // Slice on the right
-            return self.inner.right.slice(begin - left_len, end - left_len);
-        }
-
-        // Split slice
-        let left_slice = self.inner.left.slice_from(begin);
-        let right_slice = self.inner.right.slice_to(end - left_len);
-
-        Bytes::of(Rope::new(left_slice, right_slice))
-    }
-}
-
-impl ToBytes for Rope {
-    fn to_bytes(self) -> Bytes {
-        Bytes::of(self)
-    }
-}
-
-impl ops::Index<usize> for Rope {
-    type Output = u8;
-
-    fn index(&self, index: usize) -> &u8 {
-        assert!(index < self.len());
-
-        let left_len = self.inner.left.len();
-
-        if index < left_len {
-            self.inner.left.index(index)
-        } else {
-            self.inner.right.index(index - left_len)
-        }
-    }
-}
-
-impl Clone for Rope {
-    fn clone(&self) -> Rope {
-        Rope { inner: self.inner.clone() }
-    }
-}
-
-impl<'a> Source for &'a Rope {
-    type Error = BufError;
-
-    fn fill<B: MutBuf>(self, _buf: &mut B) -> Result<usize, BufError> {
-        unimplemented!();
-    }
-}
-
-/*
- *
- * ===== Helper Fns =====
- *
- */
-
-fn depth(bytes: &Bytes) -> u16 {
-    match bytes.downcast_ref::<Rope>() {
-        Some(rope) => rope.inner.depth,
-        None => 0,
-    }
-}
-
-fn is_balanced(bytes: &Bytes) -> bool {
-    if let Some(rope) = bytes.downcast_ref::<Rope>() {
-        return rope.len() >= MIN_LENGTH_BY_DEPTH[rope.depth() as usize];
-    }
-
-    true
-}
-
-fn concat(left: Bytes, right: Bytes) -> Rope {
-    if right.is_empty() {
-        return Rope::of(left);
-    }
-
-    if left.is_empty() {
-        return Rope::of(right);
-    }
-
-    let len = left.len() + right.len();
-
-    if len < CONCAT_BY_COPY_LEN {
-        return concat_bytes(&left, &right, len);
-    }
-
-    if let Some(left) = left.downcast_ref::<Rope>() {
-        let len = left.inner.right.len() + right.len();
-
-        if len < CONCAT_BY_COPY_LEN {
-            // Optimization from BAP95: As an optimization of the case
-            // where the ByteString is constructed by repeated concatenate,
-            // recognize the case where a short string is concatenated to a
-            // left-hand node whose right-hand branch is short.  In the
-            // paper this applies to leaves, but we just look at the length
-            // here. This has the advantage of shedding references to
-            // unneeded data when substrings have been taken.
-            //
-            // When we recognize this case, we do a copy of the data and
-            // create a new parent node so that the depth of the result is
-            // the same as the given left tree.
-            let new_right = concat_bytes(&left.inner.right, &right, len);
-            return Rope::new(left.inner.left.clone(), Bytes::of(new_right));
-        }
-
-        if depth(left.left()) > depth(left.right()) && left.depth() > depth(&right) {
-            // Typically for concatenate-built strings the left-side is
-            // deeper than the right.  This is our final attempt to
-            // concatenate without increasing the tree depth.  We'll redo
-            // the the node on the RHS.  This is yet another optimization
-            // for building the string by repeatedly concatenating on the
-            // right.
-            let new_right = Rope::new(left.right().clone(), right);
-            return Rope::new(left.left().clone(), Bytes::of(new_right));
-        }
-    }
-
-    // Fine, we'll add a node and increase the tree depth -- unless we
-    // rebalance ;^)
-    let depth = cmp::max(depth(&left), depth(&right)) + 1;
-
-    if len >= MIN_LENGTH_BY_DEPTH[depth as usize] {
-        // No need to rebalance
-        return Rope::new(left, right);
-    }
-
-    Balance::new().balance(left, right)
-}
-
-fn concat_bytes(left: &Bytes, right: &Bytes, len: usize) -> Rope {
-    let mut buf = ByteBuf::mut_with_capacity(len);
-
-    buf.write(left).ok().expect("unexpected error");
-    buf.write(right).ok().expect("unexpected error");
-
-    return Rope::of(buf.flip().to_bytes());
-}
-
-fn depth_for_len(len: usize) -> u16 {
-    match MIN_LENGTH_BY_DEPTH.binary_search(&len) {
-        Ok(idx) => idx as u16,
-        Err(idx) => {
-            // It wasn't an exact match, so convert to the index of the
-            // containing fragment, which is one less even than the insertion
-            // point.
-            idx as u16 - 1
-        }
-    }
-}
-
-/*
- *
- * ===== RopeBuf =====
- *
- */
-
-pub struct RopeBuf {
-    rem: usize,
-
-    // Only here for the ref count
-    #[allow(dead_code)]
-    rope: Rope,
-
-    // This must be done with unsafe code to avoid having a lifetime bound on
-    // RopeBuf but is safe due to Rope being held. As long as data doesn't
-    // escape (which it shouldn't) it is safe. Doing this properly would
-    // require HKT.
-    pieces: PieceIter<'static>,
-    leaf_buf: Option<Box<Buf+'static>>,
-}
-
-impl RopeBuf {
-    fn new(rope: Rope) -> RopeBuf {
-        // In order to get the lifetimes to work out, transmute to a 'static
-        // lifetime. Never allow the iter to escape the internals of RopeBuf.
-        let mut pieces: PieceIter<'static> =
-            unsafe { mem::transmute(rope.pieces()) };
-
-        // Get the next buf
-        let leaf_buf = pieces.next()
-            .map(|bytes| bytes.buf());
-
-        let len = rope.len();
-
-        RopeBuf {
-            rope: rope,
-            rem: len,
-            pieces: pieces,
-            leaf_buf: leaf_buf,
-        }
-    }
-}
-
-impl Buf for RopeBuf {
-    fn remaining(&self) -> usize {
-        self.rem
-    }
-
-    fn bytes(&self) -> &[u8] {
-        self.leaf_buf.as_ref()
-            .map(|b| b.bytes())
-            .unwrap_or(&[])
-    }
-
-    fn advance(&mut self, mut cnt: usize) {
-        cnt = cmp::min(cnt, self.rem);
-
-        // Advance the internal cursor
-        self.rem -= cnt;
-
-        // Advance the leaf buffer
-        while cnt > 0 {
-            {
-                let curr = self.leaf_buf.as_mut()
-                    .expect("expected a value");
-
-                if curr.remaining() > cnt {
-                    curr.advance(cnt);
-                    break;
-                }
-
-                cnt -= curr.remaining();
-            }
-
-            self.leaf_buf = self.pieces.next()
-                .map(|bytes| bytes.buf());
-        }
-    }
-}
-
-/*
- *
- * ===== PieceIter =====
- *
- */
-
-// TODO: store stack inline if possible
-struct PieceIter<'a> {
-    stack: Vec<&'a RopeInner>,
-    next: Option<&'a Bytes>,
-}
-
-impl<'a> PieceIter<'a> {
-    fn new(root: &'a RopeInner) -> PieceIter<'a> {
-        let mut iter = PieceIter {
-            stack: vec![],
-            next: None,
-        };
-
-        iter.next = iter.get_leaf_by_left(root);
-        iter
-    }
-
-    fn get_leaf_by_left(&mut self, mut root: &'a RopeInner) -> Option<&'a Bytes> {
-        loop {
-            self.stack.push(root);
-            let left = &root.left;
-
-            if left.is_empty() {
-                return None;
-            }
-
-            if let Some(rope) = left.downcast_ref::<Rope>() {
-                root = &*rope.inner;
-                continue;
-            }
-
-            return Some(left);
-        }
-    }
-
-    fn next_non_empty_leaf(&mut self) -> Option<&'a Bytes>{
-        loop {
-            if let Some(node) = self.stack.pop() {
-                if let Some(rope) = node.right.downcast_ref::<Rope>() {
-                    let res = self.get_leaf_by_left(&rope.inner);
-
-                    if res.is_none() {
-                        continue;
-                    }
-
-                    return res;
-                }
-
-                if node.right.is_empty() {
-                    continue;
-                }
-
-                return Some(&node.right);
-            }
-
-            return None;
-        }
-    }
-}
-
-impl<'a> Iterator for PieceIter<'a> {
-    type Item = &'a Bytes;
-
-    fn next(&mut self) -> Option<&'a Bytes> {
-        let ret = self.next.take();
-
-        if ret.is_some() {
-            self.next = self.next_non_empty_leaf();
-        }
-
-        ret
-    }
-}
-
-/*
- *
- * ===== Balance =====
- *
- */
-
-struct Balance {
-    stack: Vec<Bytes>,
-}
-
-impl Balance {
-    fn new() -> Balance {
-        Balance { stack: vec![] }
-    }
-
-    fn balance(&mut self, left: Bytes, right: Bytes) -> Rope {
-        self.do_balance(left);
-        self.do_balance(right);
-
-        let mut partial = self.stack.pop()
-            .expect("expected a value");
-
-        while !partial.is_empty() {
-            let new_left = self.stack.pop()
-                .expect("expected a value");
-
-            partial = Bytes::of(Rope::new(new_left, partial));
-        }
-
-        Rope::of(partial)
-    }
-
-    fn do_balance(&mut self, root: Bytes) {
-      // BAP95: Insert balanced subtrees whole. This means the result might not
-      // be balanced, leading to repeated rebalancings on concatenate. However,
-      // these rebalancings are shallow due to ignoring balanced subtrees, and
-      // relatively few calls to insert() result.
-      if is_balanced(&root) {
-          self.insert(root);
-      } else {
-          let rope = root.try_unwrap::<Rope>()
-              .ok().expect("expected a value");
-
-          self.do_balance(rope.left().clone());
-          self.do_balance(rope.right().clone());
-      }
-    }
-
-    // Push a string on the balance stack (BAP95).  BAP95 uses an array and
-    // calls the elements in the array 'bins'.  We instead use a stack, so the
-    // 'bins' of lengths are represented by differences between the elements of
-    // minLengthByDepth.
-    //
-    // If the length bin for our string, and all shorter length bins, are
-    // empty, we just push it on the stack.  Otherwise, we need to start
-    // concatenating, putting the given string in the "middle" and continuing
-    // until we land in an empty length bin that matches the length of our
-    // concatenation.
-    fn insert(&mut self, bytes: Bytes) {
-        let depth_bin = depth_for_len(bytes.len());
-        let bin_end = MIN_LENGTH_BY_DEPTH[depth_bin as usize + 1];
-
-        // BAP95: Concatenate all trees occupying bins representing the length
-        // of our new piece or of shorter pieces, to the extent that is
-        // possible.  The goal is to clear the bin which our piece belongs in,
-        // but that may not be entirely possible if there aren't enough longer
-        // bins occupied.
-        if let Some(len) = self.peek().map(|r| r.len()) {
-            if len >= bin_end {
-                self.stack.push(bytes);
-                return;
-            }
-        }
-
-        let bin_start = MIN_LENGTH_BY_DEPTH[depth_bin as usize];
-
-        // Concatenate the subtrees of shorter length
-        let mut new_tree = self.stack.pop()
-            .expect("expected a value");
-
-        while let Some(len) = self.peek().map(|r| r.len()) {
-            // If the head is big enough, break the loop
-            if len >= bin_start { break; }
-
-            let left = self.stack.pop()
-                .expect("expected a value");
-
-            new_tree = Bytes::of(Rope::new(left, new_tree));
-        }
-
-        // Concatenate the given string
-        new_tree = Bytes::of(Rope::new(new_tree, bytes));
-
-        // Continue concatenating until we land in an empty bin
-        while let Some(len) = self.peek().map(|r| r.len()) {
-            let depth_bin = depth_for_len(new_tree.len());
-            let bin_end = MIN_LENGTH_BY_DEPTH[depth_bin as usize + 1];
-
-            if len < bin_end {
-                let left = self.stack.pop()
-                    .expect("expected a value");
-
-                new_tree = Bytes::of(Rope::new(left, new_tree));
-            } else {
-                break;
-            }
-        }
-
-        self.stack.push(new_tree);
-    }
-
-    fn peek(&self) -> Option<&Bytes> {
-        self.stack.last()
-    }
-}
-
-struct RopeInner {
-    left: Bytes,
-    right: Bytes,
-    depth: u16,
-    len: u32,
-}
-
-impl RopeInner {
-    fn new(left: Bytes, right: Bytes) -> RopeInner {
-        // If left is 0 then right must be zero
-        debug_assert!(!left.is_empty() || right.is_empty());
-
-        let len = left.len() + right.len();
-        let depth = cmp::max(depth(&left), depth(&right)) + 1;
-
-        RopeInner {
-            left: left,
-            right: right,
-            depth: depth,
-            len: len as u32,
-        }
-    }
-}

src/str/seq.rs

@@ -1,100 +0,0 @@
-use {alloc, ByteBuf, MutBufExt, ByteStr, 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());
-
-        if let Err(e) = buf.write(bytes) {
-            panic!("failed to copy bytes from slice; err={:?}", e);
-        }
-
-        buf.flip().to_seq_byte_str()
-    }
-
-    /// Creates a new `SeqByteStr` from a `MemRef`, an offset, and a length.
-    ///
-    /// This function is unsafe as there are no guarantees that the given
-    /// arguments are valid.
-    pub unsafe fn from_mem_ref(mem: alloc::MemRef, pos: u32, len: u32) -> SeqByteStr {
-        SeqByteStr {
-            mem: mem,
-            pos: pos,
-            len: len,
-        }
-    }
-}
-
-impl ByteStr for SeqByteStr {
-    type Buf = ROByteBuf;
-
-    fn buf(&self) -> ROByteBuf {
-        unsafe {
-            let pos = self.pos;
-            let lim = pos + self.len;
-
-            ROByteBuf::from_mem_ref(self.mem.clone(), lim, pos, lim)
-        }
-    }
-
-    fn concat<B: ByteStr+'static>(&self, other: &B) -> Bytes {
-        Rope::of(self.clone()).concat(other)
-    }
-
-    fn len(&self) -> usize {
-        self.len as usize
-    }
-
-    fn slice(&self, begin: usize, end: usize) -> Bytes {
-        if begin >= end || begin >= self.len() {
-            return Bytes::empty()
-        }
-
-        let bytes = unsafe {
-            SeqByteStr::from_mem_ref(
-                self.mem.clone(),
-                self.pos + begin as u32,
-                (end - begin) as u32)
-        };
-
-        Bytes::of(bytes)
-    }
-}
-
-impl ToBytes for SeqByteStr {
-    fn to_bytes(self) -> Bytes {
-        Bytes::of(self)
-    }
-}
-
-impl ops::Index<usize> for SeqByteStr {
-    type Output = u8;
-
-    fn index(&self, index: usize) -> &u8 {
-        assert!(index < self.len());
-
-        unsafe {
-            &*self.mem.ptr()
-                .offset(index as isize + self.pos as isize)
-        }
-    }
-}
-
-impl Clone for SeqByteStr {
-    fn clone(&self) -> SeqByteStr {
-        SeqByteStr {
-            mem: self.mem.clone(),
-            pos: self.pos,
-            len: self.len,
-        }
-    }
-}

src/str/small.rs

@@ -1,131 +0,0 @@
-use {Bytes, Rope};
-use traits::{Buf, MutBuf, 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

@@ -1,18 +0,0 @@
-use rand::random;
-
-extern crate bytes;
-extern crate rand;
-
-mod test_buf;
-mod test_buf_fill;
-mod test_buf_take;
-mod test_byte_buf;
-mod test_bytes;
-mod test_ring;
-mod test_rope;
-mod test_seq_byte_str;
-mod test_small_byte_str;
-
-fn gen_bytes(n: usize) -> Vec<u8> {
-    (0..n).map(|_| random()).collect()
-}

test/test_buf.rs

@@ -1,50 +0,0 @@
-use bytes::{Buf, MutBuf, MutBufExt};
-use std::usize;
-use std::io::{Cursor};
-
-#[test]
-pub fn test_fresh_cursor_vec() {
-    let mut buf = Cursor::new(b"hello".to_vec());
-
-    assert_eq!(buf.remaining(), 5);
-    assert_eq!(buf.bytes(), b"hello");
-
-    buf.advance(2);
-
-    assert_eq!(buf.remaining(), 3);
-    assert_eq!(buf.bytes(), b"llo");
-
-    buf.advance(3);
-
-    assert_eq!(buf.remaining(), 0);
-    assert_eq!(buf.bytes(), b"");
-
-    buf.advance(1);
-
-    assert_eq!(buf.remaining(), 0);
-    assert_eq!(buf.bytes(), b"");
-}
-
-#[test]
-pub fn test_vec_as_mut_buf() {
-    let mut buf = Vec::with_capacity(64);
-
-    assert_eq!(buf.remaining(), usize::MAX);
-
-    unsafe {
-        assert!(buf.mut_bytes().len() >= 64);
-    }
-
-    buf.write(&b"zomg"[..]).unwrap();
-
-    assert_eq!(&buf, b"zomg");
-
-    assert_eq!(buf.remaining(), usize::MAX - 4);
-    assert_eq!(buf.capacity(), 64);
-
-    for _ in 0..16 {
-        buf.write(&b"zomg"[..]).unwrap();
-    }
-
-    assert_eq!(buf.len(), 68);
-}

test/test_buf_fill.rs

@@ -1,47 +0,0 @@
-use bytes::*;
-use std::io;
-
-#[test]
-pub fn test_filling_buf_from_reader() {
-    let mut reader = chunks(vec![b"foo", b"bar", b"baz"]);
-    let mut buf = ByteBuf::mut_with_capacity(1024);
-
-    assert_eq!(9, buf.write(&mut reader).unwrap());
-    assert_eq!(b"foobarbaz".to_bytes(), buf.flip().to_bytes());
-}
-
-fn chunks(chunks: Vec<&'static [u8]>) -> Chunked {
-    Chunked { chunks: chunks }
-}
-
-struct Chunked {
-    chunks: Vec<&'static [u8]>,
-}
-
-impl io::Read for Chunked {
-    fn read(&mut self, dst: &mut [u8]) -> io::Result<usize> {
-        use std::{cmp, ptr};
-
-        if self.chunks.is_empty() {
-            return Ok(0);
-        }
-
-        let src = self.chunks[0];
-        let len = cmp::min(src.len(), dst.len());
-
-        unsafe {
-            ptr::copy_nonoverlapping(
-                src[..len].as_ptr(),
-                dst[..len].as_mut_ptr(),
-                len);
-        }
-
-        if len < src.len() {
-            self.chunks[0] = &src[len..];
-        } else {
-            self.chunks.remove(0);
-        }
-
-        Ok(len)
-    }
-}

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);
-
-    assert_eq!(&res, b"hello");
-}

test/test_byte_buf.rs

@@ -1,71 +0,0 @@
-use bytes::ByteBuf;
-use bytes::traits::*;
-
-#[test]
-pub fn test_initial_buf_empty() {
-    let buf = ByteBuf::mut_with_capacity(100);
-
-    assert!(buf.capacity() == 128);
-    assert!(buf.remaining() == 128);
-
-    let buf = buf.flip();
-
-    assert!(buf.remaining() == 0);
-
-    let buf = buf.flip();
-
-    assert!(buf.remaining() == 128);
-}
-
-#[test]
-pub fn test_byte_buf_bytes() {
-    let mut buf = ByteBuf::mut_with_capacity(32);
-    buf.write(&b"hello "[..]).unwrap();
-    assert_eq!(&b"hello "[..], buf.bytes());
-
-    buf.write(&b"world"[..]).unwrap();
-    assert_eq!(&b"hello world"[..], buf.bytes());
-    let buf = buf.flip();
-    assert_eq!(&b"hello world"[..], buf.bytes());
-}
-
-#[test]
-pub fn test_byte_buf_read_write() {
-    let mut buf = ByteBuf::mut_with_capacity(32);
-
-    buf.write(&b"hello world"[..]).unwrap();
-    assert_eq!(21, buf.remaining());
-
-    buf.write(&b" goodbye"[..]).unwrap();
-    assert_eq!(13, buf.remaining());
-
-    let mut buf = buf.flip();
-    let mut dst = [0; 5];
-
-    buf.mark();
-    assert_eq!(5, buf.read(&mut dst[..]).unwrap());
-    assert_eq!(b"hello", &dst);
-    buf.reset();
-    assert_eq!(5, buf.read(&mut dst[..]).unwrap());
-    assert_eq!(b"hello", &dst);
-
-    assert_eq!(5, buf.read(&mut dst[..]).unwrap());
-    assert_eq!(b" worl", &dst);
-
-    let mut dst = [0; 2];
-    assert_eq!(2, buf.read(&mut dst[..]).unwrap());
-    assert_eq!(b"d ", &dst);
-
-    let mut dst = [0; 7];
-    assert_eq!(7, buf.read(&mut dst[..]).unwrap());
-    assert_eq!(b"goodbye", &dst);
-
-    let mut buf = buf.resume();
-    assert_eq!(13, buf.remaining());
-
-    buf.write(&b" have fun"[..]).unwrap();
-    assert_eq!(4, buf.remaining());
-
-    let buf = buf.flip();
-    assert_eq!(buf.bytes(), b"hello world goodbye have fun");
-}

test/test_bytes.rs

@@ -1,42 +0,0 @@
-use bytes::*;
-
-#[test]
-pub fn test_debug_short_str_valid_ascii() {
-    let b = Bytes::from_slice(b"abcdefghij234");
-    let d = format!("{:?}", b);
-
-    assert_eq!(d, "Bytes[len=13; abcdefghij234]");
-}
-
-#[test]
-pub fn test_debug_long_str_valid_ascii() {
-    let s = "Lorem ipsum dolor sit amet, consectetur adipiscing elit. \
-             Duis volutpat eros in gravida malesuada. Phasellus lobortis \
-             maximus cursus. Praesent tristique orci non purus porta \
-             dapibus. Ut ut commodo risus, sed semper felis. Phasellus \
-             bibendum dui nunc, ac pharetra dui viverra a. Nunc imperdiet \
-             sed nulla ut condimentum. In hac habitasse platea dictumst. \
-             Interdum et malesuada fames ac ante ipsum primis in faucibus. \
-             Sed facilisis dictum malesuada. Sed tempor odio ullamcorper mi \
-             iaculis, eu tempus diam semper. Vivamus pulvinar metus ac erat \
-             aliquet aliquam.";
-
-    let b = Bytes::from_slice(s.as_bytes());
-
-    let d = format!("{:?}", b);
-
-    assert_eq!(d, "Bytes[len=556; Lorem ipsum dolor sit amet, \
-                   consectetur adipiscing elit. Duis volutpat \
-                   eros in gravida malesuada. Phasellus \
-                   lobortis maximus cur ... ]");
-}
-
-#[test]
-pub fn test_short_string_invalid_ascii() {
-    let b = Bytes::from_slice(b"foo\x00bar\xFFbaz");
-    let d = format!("{:?}", b);
-
-    println!("{:?}", b);
-
-    assert_eq!(d, "Bytes[len=11; foo\\x00bar\\xFFbaz]");
-}

test/test_ring.rs

@@ -1,138 +0,0 @@
-use bytes::RingBuf;
-
-
-#[test]
-pub fn test_initial_buf_empty() {
-    use bytes::traits::{Buf, BufExt, MutBuf, MutBufExt};
-
-    let mut buf = RingBuf::new(16);
-    assert_eq!(MutBuf::remaining(&buf), 16);
-    assert_eq!(Buf::remaining(&buf), 0);
-
-    let bytes_written = buf.write(&[1, 2, 3][..]).unwrap();
-    assert_eq!(bytes_written, 3);
-
-    let bytes_written = buf.write(&[][..]).unwrap();
-    assert_eq!(bytes_written, 0);
-    assert_eq!(MutBuf::remaining(&buf), 13);
-    assert_eq!(Buf::remaining(&buf), 3);
-    assert_eq!(buf.bytes(), [1, 2, 3]);
-
-    let mut out = [0u8; 3];
-
-    buf.mark();
-    let bytes_read = buf.read(&mut out[..]).unwrap();;
-    assert_eq!(bytes_read, 3);
-    assert_eq!(out, [1, 2, 3]);
-    buf.reset();
-    let bytes_read = buf.read(&mut out[..]).unwrap();;
-    assert_eq!(bytes_read, 3);
-    assert_eq!(out, [1, 2, 3]);
-
-    assert_eq!(MutBuf::remaining(&buf), 16);
-    assert_eq!(Buf::remaining(&buf), 0);
-}
-
-#[test]
-fn test_wrapping_write() {
-    use bytes::traits::{BufExt, MutBufExt};
-    let mut buf = RingBuf::new(16);
-    let mut out = [0;10];
-
-    buf.write(&[42;12][..]).unwrap();
-    let bytes_read = buf.read(&mut out[..]).unwrap();
-    assert_eq!(bytes_read, 10);
-
-    let bytes_written = buf.write(&[23;8][..]).unwrap();
-    assert_eq!(bytes_written, 8);
-
-    buf.mark();
-    let bytes_read = buf.read(&mut out[..]).unwrap();
-    assert_eq!(bytes_read, 10);
-    assert_eq!(out, [42, 42, 23, 23, 23, 23, 23, 23, 23, 23]);
-    buf.reset();
-    let bytes_read = buf.read(&mut out[..]).unwrap();
-    assert_eq!(bytes_read, 10);
-    assert_eq!(out, [42, 42, 23, 23, 23, 23, 23, 23, 23, 23]);
-}
-
-#[test]
-fn test_io_write_and_read() {
-    use std::io::{Read, Write};
-
-    let mut buf = RingBuf::new(16);
-    let mut out = [0;8];
-
-    let written = buf.write(&[1;8][..]).unwrap();
-    assert_eq!(written, 8);
-
-    buf.read(&mut out).unwrap();
-    assert_eq!(out, [1;8]);
-
-    let written = buf.write(&[2;8][..]).unwrap();
-    assert_eq!(written, 8);
-
-    let bytes_read = buf.read(&mut out).unwrap();
-    assert_eq!(bytes_read, 8);
-    assert_eq!(out, [2;8]);
-}
-
-#[test]
-#[should_panic]
-fn test_wrap_reset() {
-    use std::io::{Read, Write};
-
-    let mut buf = RingBuf::new(8);
-    buf.write(&[1, 2, 3, 4, 5, 6, 7]).unwrap();
-    buf.mark();
-    buf.read(&mut [0; 4]).unwrap();
-    buf.write(&[1, 2, 3, 4]).unwrap();
-    buf.reset();
-}
-
-#[test]
-// Test that writes across a mark/reset are preserved.
-fn test_mark_write() {
-    use std::io::{Read, Write};
-
-    let mut buf = RingBuf::new(8);
-    buf.write(&[1, 2, 3, 4, 5, 6, 7]).unwrap();
-    buf.mark();
-    buf.write(&[8]).unwrap();
-    buf.reset();
-
-    let mut buf2 = [0; 8];
-    buf.read(&mut buf2).unwrap();
-    assert_eq!(buf2, [1, 2, 3, 4, 5, 6, 7, 8]);
-}
-
-#[test]
-// Test that "RingBuf::reset" does not reset the length of a
-// full buffer to zero.
-fn test_reset_full() {
-    use bytes::traits::MutBuf;
-    use std::io::Write;
-
-    let mut buf = RingBuf::new(8);
-    buf.write(&[1, 2, 3, 4, 5, 6, 7, 8]).unwrap();
-    assert_eq!(MutBuf::remaining(&buf), 0);
-    buf.mark();
-    buf.reset();
-    assert_eq!(MutBuf::remaining(&buf), 0);
-}
-
-
-#[test]
-// Test that "RingBuf::clear" does the full reset
-fn test_clear() {
-    use bytes::traits::{Buf, MutBuf};
-    use std::io::Write;
-
-    let mut buf = RingBuf::new(8);
-    buf.write(&[0; 8]).unwrap();
-    assert_eq!(MutBuf::remaining(&buf), 0);
-    assert_eq!(Buf::remaining(&buf), 8);
-    buf.clear();
-    assert_eq!(MutBuf::remaining(&buf), 8);
-    assert_eq!(Buf::remaining(&buf), 0);
-}

test/test_rope.rs

@@ -1,107 +0,0 @@
-use bytes::Rope;
-use bytes::traits::*;
-use super::gen_bytes;
-
-const TEST_BYTES_1: &'static [u8] =
-    b"dblm4ng7jp4v9rdn1w6hhssmluoqrrrqj59rccl9
-      nkv2tm1t2da4jyku51ge7f8hv581gkki8lekmf5f
-      1l44whp4aiwbvhkziw02292on4noyvuwjzsloqyc
-      5n0iyn4l6o6tgjhlek00mynfzb1wgcwj4mqp6zdr
-      3625yy7rj7xuisal7b1a7xgq271abvt5ssxuj39v
-      njtetokxxrgxzp7ik9adnypkmmcn4270yv9l46m7
-      9mu2zmqmkxdmgia210vkdytb7ywfcyt2bvcsg9eq
-      5yqizxl6888zrksvaxhzs2v355jxu8gr21m33t83
-      qvoian1ra7c6pvxabshgngldxa408p18l1fdet2h";
-
-const TEST_BYTES_2: &'static [u8] =
-    b"jmh14t79mllzj1ohxfj6fun7idwbks8oh35f83g6
-      ryaowe86mmou5t1xa91uyg8e95wcu5mje1mswien
-      tt4clgj029cw0pyuvfbvsgzdg1x7sr9qsjkf2b1t
-      h43smgp1ea22lph17f78cel0cc2kjoht5281xuy8
-      0ex9uaqwj4330jrp30stsk15j9bpqezu3w78ktit
-      ev5g6xsngr35q7pemdm9hihf0ebrw5fbwhm530lo
-      e0zyj1bm7yfyk7f2i45jhr3wu3bvb4hj8jve6db0
-      iewmr9weecaon9vdnqo5hen9iaiox5vsaxuo461m
-      8336ugp20u4sfky3kfawr0ome1tiqyx8chkerrjh
-      a95s0gypcsgo9jqxasqkoj08t4uq5moxmay5plg5
-      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().read(&mut dst).unwrap();
-
-    assert_eq!(b"zomg", &dst[..]);
-}
-
-#[test]
-pub fn test_rope_slice() {
-    let mut dst = vec![];
-
-    let bytes = Rope::from_slice(TEST_BYTES_1);
-    assert_eq!(TEST_BYTES_1.len(), bytes.len());
-
-    bytes.buf().read(&mut dst).unwrap();
-    assert_eq!(dst, TEST_BYTES_1);
-
-    let left = bytes.slice_to(250);
-    assert_eq!(250, left.len());
-
-    left.buf().read(&mut dst).unwrap();
-    assert_eq!(dst, &TEST_BYTES_1[..250]);
-
-    let right = bytes.slice_from(250);
-    assert_eq!(TEST_BYTES_1.len() - 250, right.len());
-
-    right.buf().read(&mut dst).unwrap();
-    assert_eq!(dst, &TEST_BYTES_1[250..]);
-}
-
-#[test]
-pub fn test_rope_concat_two_byte_str() {
-    let mut dst = vec![];
-
-    let left = Rope::from_slice(TEST_BYTES_1);
-    let right = Rope::from_slice(TEST_BYTES_2);
-
-    let both = left.concat(&right);
-
-    assert_eq!(both.len(), TEST_BYTES_1.len() + TEST_BYTES_2.len());
-
-    both.buf().read(&mut dst).unwrap();
-    let mut expected = Vec::new();
-    expected.extend(TEST_BYTES_1.iter().cloned());
-    expected.extend(TEST_BYTES_2.iter().cloned());
-    assert_eq!(dst, expected);
-}
-
-#[test]
-#[ignore]
-pub fn test_slice_parity() {
-    let bytes = gen_bytes(2048 * 1024);
-    let start = 512 * 1024 - 3333;
-    let end = 512 * 1024 + 7777;
-
-    let _ = Rope::from_slice(&bytes).slice(start, end);
-
-    // stuff
-}
-
-#[test]
-pub fn test_rope_equality() {
-    let a = &b"Mary had a little lamb, its fleece was white as snow; ".to_bytes()
-        .concat(&b"And everywhere that Mary went, the lamb was sure to go.".to_bytes());
-
-    let b = &b"Mary had a little lamb, ".to_bytes()
-        .concat(&b"its fleece was white as snow; ".to_bytes())
-        .concat(
-            &b"And everywhere that Mary went, ".to_bytes()
-                .concat(&b"the lamb was sure to go.".to_bytes()));
-
-    assert_eq!(a, b);
-}

test/test_seq_byte_str.rs

@@ -1,33 +0,0 @@
-use bytes::SeqByteStr;
-use bytes::traits::*;
-use super::gen_bytes;
-
-#[test]
-pub fn test_slice_round_trip() {
-    let mut dst = vec![];
-    let src = gen_bytes(2000);
-
-    let s = SeqByteStr::from_slice(&src);
-    assert_eq!(2000, s.len());
-
-    s.buf().read(&mut dst).unwrap();
-    assert_eq!(dst, src);
-}
-
-#[test]
-pub fn test_index() {
-    let src = gen_bytes(2000);
-
-    let s = SeqByteStr::from_slice(&src);
-
-    for i in 0..2000 {
-        assert_eq!(src[i], s[i]);
-    }
-}
-
-#[test]
-#[should_panic]
-pub fn test_index_out_of_range() {
-    let s = SeqByteStr::from_slice(&gen_bytes(2000));
-    let _ = s[2001];
-}

test/test_small_byte_str.rs

@@ -1,33 +0,0 @@
-use bytes::SmallByteStr;
-use bytes::traits::*;
-use super::gen_bytes;
-
-#[test]
-pub fn test_slice_round_trip() {
-    let mut dst = vec![];
-    let src = gen_bytes(3);
-
-    let s = SmallByteStr::from_slice(&src).unwrap();
-    assert_eq!(3, s.len());
-
-    s.buf().read(&mut dst).unwrap();
-    assert_eq!(dst, src);
-}
-
-#[test]
-pub fn test_index() {
-    let src = gen_bytes(3);
-
-    let s = SmallByteStr::from_slice(&src).unwrap();
-
-    for i in 0..3 {
-        assert_eq!(src[i], s[i]);
-    }
-}
-
-#[test]
-#[should_panic]
-pub fn test_index_out_of_range() {
-    let s = SmallByteStr::from_slice(&gen_bytes(3)).unwrap();
-    let _ = s[2001];
-}

tests/test_buf.rs

@@ -0,0 +1,71 @@
+#![deny(warnings, rust_2018_idioms)]
+
+use bytes::Buf;
+use std::io::IoSlice;
+
+#[test]
+fn test_fresh_cursor_vec() {
+    let mut buf = &b"hello"[..];
+
+    assert_eq!(buf.remaining(), 5);
+    assert_eq!(buf.bytes(), b"hello");
+
+    buf.advance(2);
+
+    assert_eq!(buf.remaining(), 3);
+    assert_eq!(buf.bytes(), b"llo");
+
+    buf.advance(3);
+
+    assert_eq!(buf.remaining(), 0);
+    assert_eq!(buf.bytes(), b"");
+}
+
+#[test]
+fn test_get_u8() {
+    let mut buf = &b"\x21zomg"[..];
+    assert_eq!(0x21, buf.get_u8());
+}
+
+#[test]
+fn test_get_u16() {
+    let mut buf = &b"\x21\x54zomg"[..];
+    assert_eq!(0x2154, buf.get_u16());
+    let mut buf = &b"\x21\x54zomg"[..];
+    assert_eq!(0x5421, buf.get_u16_le());
+}
+
+#[test]
+#[should_panic]
+fn test_get_u16_buffer_underflow() {
+    let mut buf = &b"\x21"[..];
+    buf.get_u16();
+}
+
+#[test]
+fn test_bufs_vec() {
+    let buf = &b"hello world"[..];
+
+    let b1: &[u8] = &mut [];
+    let b2: &[u8] = &mut [];
+
+    let mut dst = [IoSlice::new(b1), IoSlice::new(b2)];
+
+    assert_eq!(1, buf.bytes_vectored(&mut dst[..]));
+}
+
+#[test]
+fn test_vec_deque() {
+    use std::collections::VecDeque;
+
+    let mut buffer: VecDeque<u8> = VecDeque::new();
+    buffer.extend(b"hello world");
+    assert_eq!(11, buffer.remaining());
+    assert_eq!(b"hello world", buffer.bytes());
+    buffer.advance(6);
+    assert_eq!(b"world", buffer.bytes());
+    buffer.extend(b" piece");
+    let mut out = [0; 11];
+    buffer.copy_to_slice(&mut out);
+    assert_eq!(b"world piece", &out[..]);
+}

tests/test_buf_mut.rs

@@ -0,0 +1,89 @@
+#![deny(warnings, rust_2018_idioms)]
+
+use bytes::{buf::IoSliceMut, BufMut, BytesMut};
+use std::usize;
+use std::fmt::Write;
+
+#[test]
+fn test_vec_as_mut_buf() {
+    let mut buf = Vec::with_capacity(64);
+
+    assert_eq!(buf.remaining_mut(), usize::MAX);
+
+    assert!(buf.bytes_mut().len() >= 64);
+
+    buf.put(&b"zomg"[..]);
+
+    assert_eq!(&buf, b"zomg");
+
+    assert_eq!(buf.remaining_mut(), usize::MAX - 4);
+    assert_eq!(buf.capacity(), 64);
+
+    for _ in 0..16 {
+        buf.put(&b"zomg"[..]);
+    }
+
+    assert_eq!(buf.len(), 68);
+}
+
+#[test]
+fn test_put_u8() {
+    let mut buf = Vec::with_capacity(8);
+    buf.put_u8(33);
+    assert_eq!(b"\x21", &buf[..]);
+}
+
+#[test]
+fn test_put_u16() {
+    let mut buf = Vec::with_capacity(8);
+    buf.put_u16(8532);
+    assert_eq!(b"\x21\x54", &buf[..]);
+
+    buf.clear();
+    buf.put_u16_le(8532);
+    assert_eq!(b"\x54\x21", &buf[..]);
+}
+
+#[test]
+fn test_vec_advance_mut() {
+    // Regression test for carllerche/bytes#108.
+    let mut buf = Vec::with_capacity(8);
+    unsafe {
+        buf.advance_mut(12);
+        assert_eq!(buf.len(), 12);
+        assert!(buf.capacity() >= 12, "capacity: {}", buf.capacity());
+    }
+}
+
+#[test]
+fn test_clone() {
+    let mut buf = BytesMut::with_capacity(100);
+    buf.write_str("this is a test").unwrap();
+    let buf2 = buf.clone();
+
+    buf.write_str(" of our emergency broadcast system").unwrap();
+    assert!(buf != buf2);
+}
+
+#[test]
+fn test_bufs_vec_mut() {
+    let b1: &mut [u8] = &mut [];
+    let b2: &mut [u8] = &mut [];
+    let mut dst = [IoSliceMut::from(b1), IoSliceMut::from(b2)];
+
+    // with no capacity
+    let mut buf = BytesMut::new();
+    assert_eq!(buf.capacity(), 0);
+    assert_eq!(1, buf.bytes_vectored_mut(&mut dst[..]));
+
+    // with capacity
+    let mut buf = BytesMut::with_capacity(64);
+    assert_eq!(1, buf.bytes_vectored_mut(&mut dst[..]));
+}
+
+#[test]
+fn test_mut_slice() {
+    let mut v = vec![0, 0, 0, 0];
+    let mut s = &mut v[..];
+    s.put_u32(42);
+}

tests/test_bytes.rs

@@ -0,0 +1,855 @@
+#![deny(warnings, rust_2018_idioms)]
+
+use bytes::{Bytes, BytesMut, Buf, BufMut};
+
+use std::usize;
+
+const LONG: &'static [u8] = b"mary had a little lamb, little lamb, little lamb";
+const SHORT: &'static [u8] = b"hello world";
+
+fn is_sync<T: Sync>() {}
+fn is_send<T: Send>() {}
+
+#[test]
+fn test_bounds() {
+    is_sync::<Bytes>();
+    is_sync::<BytesMut>();
+    is_send::<Bytes>();
+    is_send::<BytesMut>();
+}
+
+#[test]
+fn test_layout() {
+    use std::mem;
+
+    assert_eq!(
+        mem::size_of::<Bytes>(),
+        mem::size_of::<usize>() * 4,
+        "Bytes size should be 4 words",
+    );
+    assert_eq!(
+        mem::size_of::<BytesMut>(),
+        mem::size_of::<usize>() * 4,
+        "BytesMut should be 4 words",
+    );
+
+    assert_eq!(
+        mem::size_of::<Bytes>(),
+        mem::size_of::<Option<Bytes>>(),
+        "Bytes should be same size as Option<Bytes>",
+    );
+
+    assert_eq!(
+        mem::size_of::<BytesMut>(),
+        mem::size_of::<Option<BytesMut>>(),
+        "BytesMut should be same size as Option<BytesMut>",
+    );
+
+}
+
+#[test]
+fn from_slice() {
+    let a = Bytes::from(&b"abcdefgh"[..]);
+    assert_eq!(a, b"abcdefgh"[..]);
+    assert_eq!(a, &b"abcdefgh"[..]);
+    assert_eq!(a, Vec::from(&b"abcdefgh"[..]));
+    assert_eq!(b"abcdefgh"[..], a);
+    assert_eq!(&b"abcdefgh"[..], a);
+    assert_eq!(Vec::from(&b"abcdefgh"[..]), a);
+
+    let a = BytesMut::from(&b"abcdefgh"[..]);
+    assert_eq!(a, b"abcdefgh"[..]);
+    assert_eq!(a, &b"abcdefgh"[..]);
+    assert_eq!(a, Vec::from(&b"abcdefgh"[..]));
+    assert_eq!(b"abcdefgh"[..], a);
+    assert_eq!(&b"abcdefgh"[..], a);
+    assert_eq!(Vec::from(&b"abcdefgh"[..]), a);
+}
+
+#[test]
+fn fmt() {
+    let a = format!("{:?}", Bytes::from(&b"abcdefg"[..]));
+    let b = "b\"abcdefg\"";
+
+    assert_eq!(a, b);
+
+    let a = format!("{:?}", BytesMut::from(&b"abcdefg"[..]));
+    assert_eq!(a, b);
+}
+
+#[test]
+fn fmt_write() {
+    use std::fmt::Write;
+    use std::iter::FromIterator;
+    let s = String::from_iter((0..10).map(|_| "abcdefg"));
+
+    let mut a = BytesMut::with_capacity(64);
+    write!(a, "{}", &s[..64]).unwrap();
+    assert_eq!(a, s[..64].as_bytes());
+
+
+    let mut b = BytesMut::with_capacity(64);
+    write!(b, "{}", &s[..32]).unwrap();
+    write!(b, "{}", &s[32..64]).unwrap();
+    assert_eq!(b, s[..64].as_bytes());
+
+
+    let mut c = BytesMut::with_capacity(64);
+    write!(c, "{}", s).unwrap();
+    assert_eq!(c, s[..].as_bytes());
+}
+
+#[test]
+fn len() {
+    let a = Bytes::from(&b"abcdefg"[..]);
+    assert_eq!(a.len(), 7);
+
+    let a = BytesMut::from(&b"abcdefg"[..]);
+    assert_eq!(a.len(), 7);
+
+    let a = Bytes::from(&b""[..]);
+    assert!(a.is_empty());
+
+    let a = BytesMut::from(&b""[..]);
+    assert!(a.is_empty());
+}
+
+#[test]
+fn index() {
+    let a = Bytes::from(&b"hello world"[..]);
+    assert_eq!(a[0..5], *b"hello");
+}
+
+#[test]
+fn slice() {
+    let a = Bytes::from(&b"hello world"[..]);
+
+    let b = a.slice(3..5);
+    assert_eq!(b, b"lo"[..]);
+
+    let b = a.slice(0..0);
+    assert_eq!(b, b""[..]);
+
+    let b = a.slice(3..3);
+    assert_eq!(b, b""[..]);
+
+    let b = a.slice(a.len()..a.len());
+    assert_eq!(b, b""[..]);
+
+    let b = a.slice(..5);
+    assert_eq!(b, b"hello"[..]);
+
+    let b = a.slice(3..);
+    assert_eq!(b, b"lo world"[..]);
+}
+
+#[test]
+#[should_panic]
+fn slice_oob_1() {
+    let a = Bytes::from(&b"hello world"[..]);
+    a.slice(5..44);
+}
+
+#[test]
+#[should_panic]
+fn slice_oob_2() {
+    let a = Bytes::from(&b"hello world"[..]);
+    a.slice(44..49);
+}
+
+#[test]
+fn split_off() {
+    let mut hello = Bytes::from(&b"helloworld"[..]);
+    let world = hello.split_off(5);
+
+    assert_eq!(hello, &b"hello"[..]);
+    assert_eq!(world, &b"world"[..]);
+
+    let mut hello = BytesMut::from(&b"helloworld"[..]);
+    let world = hello.split_off(5);
+
+    assert_eq!(hello, &b"hello"[..]);
+    assert_eq!(world, &b"world"[..]);
+}
+
+#[test]
+#[should_panic]
+fn split_off_oob() {
+    let mut hello = Bytes::from(&b"helloworld"[..]);
+    hello.split_off(44);
+}
+
+#[test]
+fn split_off_uninitialized() {
+    let mut bytes = BytesMut::with_capacity(1024);
+    let other = bytes.split_off(128);
+
+    assert_eq!(bytes.len(), 0);
+    assert_eq!(bytes.capacity(), 128);
+
+    assert_eq!(other.len(), 0);
+    assert_eq!(other.capacity(), 896);
+}
+
+#[test]
+fn split_off_to_loop() {
+    let s = b"abcdefghijklmnopqrstuvwxyzABCDEFGHIJKLMNOPQRSTUVWXYZ";
+
+    for i in 0..(s.len() + 1) {
+        {
+            let mut bytes = Bytes::from(&s[..]);
+            let off = bytes.split_off(i);
+            assert_eq!(i, bytes.len());
+            let mut sum = Vec::new();
+            sum.extend(bytes.iter());
+            sum.extend(off.iter());
+            assert_eq!(&s[..], &sum[..]);
+        }
+        {
+            let mut bytes = BytesMut::from(&s[..]);
+            let off = bytes.split_off(i);
+            assert_eq!(i, bytes.len());
+            let mut sum = Vec::new();
+            sum.extend(&bytes);
+            sum.extend(&off);
+            assert_eq!(&s[..], &sum[..]);
+        }
+        {
+            let mut bytes = Bytes::from(&s[..]);
+            let off = bytes.split_to(i);
+            assert_eq!(i, off.len());
+            let mut sum = Vec::new();
+            sum.extend(off.iter());
+            sum.extend(bytes.iter());
+            assert_eq!(&s[..], &sum[..]);
+        }
+        {
+            let mut bytes = BytesMut::from(&s[..]);
+            let off = bytes.split_to(i);
+            assert_eq!(i, off.len());
+            let mut sum = Vec::new();
+            sum.extend(&off);
+            sum.extend(&bytes);
+            assert_eq!(&s[..], &sum[..]);
+        }
+    }
+}
+
+#[test]
+fn split_to_1() {
+    // Static
+    let mut a = Bytes::from_static(SHORT);
+    let b = a.split_to(4);
+
+    assert_eq!(SHORT[4..], a);
+    assert_eq!(SHORT[..4], b);
+
+    // Allocated
+    let mut a = Bytes::copy_from_slice(LONG);
+    let b = a.split_to(4);
+
+    assert_eq!(LONG[4..], a);
+    assert_eq!(LONG[..4], b);
+
+    let mut a = Bytes::copy_from_slice(LONG);
+    let b = a.split_to(30);
+
+    assert_eq!(LONG[30..], a);
+    assert_eq!(LONG[..30], b);
+}
+
+#[test]
+fn split_to_2() {
+    let mut a = Bytes::from(LONG);
+    assert_eq!(LONG, a);
+
+    let b = a.split_to(1);
+
+    assert_eq!(LONG[1..], a);
+    drop(b);
+}
+
+#[test]
+#[should_panic]
+fn split_to_oob() {
+    let mut hello = Bytes::from(&b"helloworld"[..]);
+    hello.split_to(33);
+}
+
+#[test]
+#[should_panic]
+fn split_to_oob_mut() {
+    let mut hello = BytesMut::from(&b"helloworld"[..]);
+    hello.split_to(33);
+}
+
+#[test]
+#[should_panic]
+fn split_to_uninitialized() {
+    let mut bytes = BytesMut::with_capacity(1024);
+    let _other = bytes.split_to(128);
+}
+
+#[test]
+fn split_off_to_at_gt_len() {
+    fn make_bytes() -> Bytes {
+        let mut bytes = BytesMut::with_capacity(100);
+        bytes.put_slice(&[10, 20, 30, 40]);
+        bytes.freeze()
+    }
+
+    use std::panic;
+
+    make_bytes().split_to(4);
+    make_bytes().split_off(4);
+
+    assert!(panic::catch_unwind(move || {
+        make_bytes().split_to(5);
+    }).is_err());
+
+    assert!(panic::catch_unwind(move || {
+        make_bytes().split_off(5);
+    }).is_err());
+}
+
+#[test]
+fn freeze_clone_shared() {
+    let s = &b"abcdefgh"[..];
+    let b = BytesMut::from(s).split().freeze();
+    assert_eq!(b, s);
+    let c = b.clone();
+    assert_eq!(c, s);
+}
+
+#[test]
+fn freeze_clone_unique() {
+    let s = &b"abcdefgh"[..];
+    let b = BytesMut::from(s).freeze();
+    assert_eq!(b, s);
+    let c = b.clone();
+    assert_eq!(c, s);
+}
+
+#[test]
+fn fns_defined_for_bytes_mut() {
+    let mut bytes = BytesMut::from(&b"hello world"[..]);
+
+    bytes.as_ptr();
+    bytes.as_mut_ptr();
+
+    // Iterator
+    let v: Vec<u8> = bytes.as_ref().iter().cloned().collect();
+    assert_eq!(&v[..], bytes);
+}
+
+#[test]
+fn reserve_convert() {
+    // Vec -> Vec
+    let mut bytes = BytesMut::from(LONG);
+    bytes.reserve(64);
+    assert_eq!(bytes.capacity(), LONG.len() + 64);
+
+    // Arc -> Vec
+    let mut bytes = BytesMut::from(LONG);
+    let a = bytes.split_to(30);
+
+    bytes.reserve(128);
+    assert!(bytes.capacity() >= bytes.len() + 128);
+
+    drop(a);
+}
+
+#[test]
+fn reserve_growth() {
+    let mut bytes = BytesMut::with_capacity(64);
+    bytes.put("hello world".as_bytes());
+    let _ = bytes.split();
+
+    bytes.reserve(65);
+    assert_eq!(bytes.capacity(), 128);
+}
+
+#[test]
+fn reserve_allocates_at_least_original_capacity() {
+    let mut bytes = BytesMut::with_capacity(1024);
+
+    for i in 0..1020 {
+        bytes.put_u8(i as u8);
+    }
+
+    let _other = bytes.split();
+
+    bytes.reserve(16);
+    assert_eq!(bytes.capacity(), 1024);
+}
+
+#[test]
+fn reserve_max_original_capacity_value() {
+    const SIZE: usize = 128 * 1024;
+
+    let mut bytes = BytesMut::with_capacity(SIZE);
+
+    for _ in 0..SIZE {
+        bytes.put_u8(0u8);
+    }
+
+    let _other = bytes.split();
+
+    bytes.reserve(16);
+    assert_eq!(bytes.capacity(), 64 * 1024);
+}
+
+#[test]
+fn reserve_vec_recycling() {
+    let mut bytes = BytesMut::with_capacity(16);
+    assert_eq!(bytes.capacity(), 16);
+    let addr = bytes.as_ptr() as usize;
+    bytes.put("0123456789012345".as_bytes());
+    assert_eq!(bytes.as_ptr() as usize, addr);
+    bytes.advance(10);
+    assert_eq!(bytes.capacity(), 6);
+    bytes.reserve(8);
+    assert_eq!(bytes.capacity(), 16);
+    assert_eq!(bytes.as_ptr() as usize, addr);
+}
+
+#[test]
+fn reserve_in_arc_unique_does_not_overallocate() {
+    let mut bytes = BytesMut::with_capacity(1000);
+    bytes.split();
+
+    // now bytes is Arc and refcount == 1
+
+    assert_eq!(1000, bytes.capacity());
+    bytes.reserve(2001);
+    assert_eq!(2001, bytes.capacity());
+}
+
+#[test]
+fn reserve_in_arc_unique_doubles() {
+    let mut bytes = BytesMut::with_capacity(1000);
+    bytes.split();
+
+    // now bytes is Arc and refcount == 1
+
+    assert_eq!(1000, bytes.capacity());
+    bytes.reserve(1001);
+    assert_eq!(2000, bytes.capacity());
+}
+
+#[test]
+fn reserve_in_arc_nonunique_does_not_overallocate() {
+    let mut bytes = BytesMut::with_capacity(1000);
+    let _copy = bytes.split();
+
+    // now bytes is Arc and refcount == 2
+
+    assert_eq!(1000, bytes.capacity());
+    bytes.reserve(2001);
+    assert_eq!(2001, bytes.capacity());
+}
+
+#[test]
+fn extend_mut() {
+    let mut bytes = BytesMut::with_capacity(0);
+    bytes.extend(LONG);
+    assert_eq!(*bytes, LONG[..]);
+}
+
+#[test]
+fn extend_from_slice_mut() {
+    for &i in &[3, 34] {
+        let mut bytes = BytesMut::new();
+        bytes.extend_from_slice(&LONG[..i]);
+        bytes.extend_from_slice(&LONG[i..]);
+        assert_eq!(LONG[..], *bytes);
+    }
+}
+
+#[test]
+fn extend_mut_without_size_hint() {
+    let mut bytes = BytesMut::with_capacity(0);
+    let mut long_iter = LONG.iter();
+
+    // Use iter::from_fn since it doesn't know a size_hint
+    bytes.extend(std::iter::from_fn(|| long_iter.next()));
+    assert_eq!(*bytes, LONG[..]);
+}
+
+#[test]
+fn from_static() {
+    let mut a = Bytes::from_static(b"ab");
+    let b = a.split_off(1);
+
+    assert_eq!(a, b"a"[..]);
+    assert_eq!(b, b"b"[..]);
+}
+
+#[test]
+fn advance_static() {
+    let mut a = Bytes::from_static(b"hello world");
+    a.advance(6);
+    assert_eq!(a, &b"world"[..]);
+}
+
+#[test]
+fn advance_vec() {
+    let mut a = Bytes::from(b"hello world boooo yah world zomg wat wat".to_vec());
+    a.advance(16);
+    assert_eq!(a, b"o yah world zomg wat wat"[..]);
+
+    a.advance(4);
+    assert_eq!(a, b"h world zomg wat wat"[..]);
+
+    a.advance(6);
+    assert_eq!(a, b"d zomg wat wat"[..]);
+}
+
+#[test]
+fn advance_bytes_mut() {
+    let mut a = BytesMut::from("hello world boooo yah world zomg wat wat");
+    a.advance(16);
+    assert_eq!(a, b"o yah world zomg wat wat"[..]);
+
+    a.advance(4);
+    assert_eq!(a, b"h world zomg wat wat"[..]);
+
+    // Reserve some space.
+    a.reserve(1024);
+    assert_eq!(a, b"h world zomg wat wat"[..]);
+
+    a.advance(6);
+    assert_eq!(a, b"d zomg wat wat"[..]);
+}
+
+#[test]
+#[should_panic]
+fn advance_past_len() {
+    let mut a = BytesMut::from("hello world");
+    a.advance(20);
+}
+
+#[test]
+// Only run these tests on little endian systems. CI uses qemu for testing
+// little endian... and qemu doesn't really support threading all that well.
+#[cfg(target_endian = "little")]
+fn stress() {
+    // Tests promoting a buffer from a vec -> shared in a concurrent situation
+    use std::sync::{Arc, Barrier};
+    use std::thread;
+
+    const THREADS: usize = 8;
+    const ITERS: usize = 1_000;
+
+    for i in 0..ITERS {
+        let data = [i as u8; 256];
+        let buf = Arc::new(Bytes::copy_from_slice(&data[..]));
+
+        let barrier = Arc::new(Barrier::new(THREADS));
+        let mut joins = Vec::with_capacity(THREADS);
+
+        for _ in 0..THREADS {
+            let c = barrier.clone();
+            let buf = buf.clone();
+
+            joins.push(thread::spawn(move || {
+                c.wait();
+                let buf: Bytes = (*buf).clone();
+                drop(buf);
+            }));
+        }
+
+        for th in joins {
+            th.join().unwrap();
+        }
+
+        assert_eq!(*buf, data[..]);
+    }
+}
+
+#[test]
+fn partial_eq_bytesmut() {
+    let bytes = Bytes::from(&b"The quick red fox"[..]);
+    let bytesmut = BytesMut::from(&b"The quick red fox"[..]);
+    assert!(bytes == bytesmut);
+    assert!(bytesmut == bytes);
+    let bytes2 = Bytes::from(&b"Jumped over the lazy brown dog"[..]);
+    assert!(bytes2 != bytesmut);
+    assert!(bytesmut != bytes2);
+}
+
+/*
+#[test]
+fn bytes_unsplit_basic() {
+    let buf = Bytes::from(&b"aaabbbcccddd"[..]);
+
+    let splitted = buf.split_off(6);
+    assert_eq!(b"aaabbb", &buf[..]);
+    assert_eq!(b"cccddd", &splitted[..]);
+
+    buf.unsplit(splitted);
+    assert_eq!(b"aaabbbcccddd", &buf[..]);
+}
+
+#[test]
+fn bytes_unsplit_empty_other() {
+    let buf = Bytes::from(&b"aaabbbcccddd"[..]);
+
+    // empty other
+    let other = Bytes::new();
+
+    buf.unsplit(other);
+    assert_eq!(b"aaabbbcccddd", &buf[..]);
+}
+
+#[test]
+fn bytes_unsplit_empty_self() {
+    // empty self
+    let mut buf = Bytes::new();
+
+    let mut other = Bytes::with_capacity(64);
+    other.extend_from_slice(b"aaabbbcccddd");
+
+    buf.unsplit(other);
+    assert_eq!(b"aaabbbcccddd", &buf[..]);
+}
+
+#[test]
+fn bytes_unsplit_arc_different() {
+    let mut buf = Bytes::with_capacity(64);
+    buf.extend_from_slice(b"aaaabbbbeeee");
+
+    buf.split_off(8); //arc
+
+    let mut buf2 = Bytes::with_capacity(64);
+    buf2.extend_from_slice(b"ccccddddeeee");
+
+    buf2.split_off(8); //arc
+
+    buf.unsplit(buf2);
+    assert_eq!(b"aaaabbbbccccdddd", &buf[..]);
+}
+
+#[test]
+fn bytes_unsplit_arc_non_contiguous() {
+    let mut buf = Bytes::with_capacity(64);
+    buf.extend_from_slice(b"aaaabbbbeeeeccccdddd");
+
+    let mut buf2 = buf.split_off(8); //arc
+
+    let buf3 = buf2.split_off(4); //arc
+
+    buf.unsplit(buf3);
+    assert_eq!(b"aaaabbbbccccdddd", &buf[..]);
+}
+
+#[test]
+fn bytes_unsplit_two_split_offs() {
+    let mut buf = Bytes::with_capacity(64);
+    buf.extend_from_slice(b"aaaabbbbccccdddd");
+
+    let mut buf2 = buf.split_off(8); //arc
+    let buf3 = buf2.split_off(4); //arc
+
+    buf2.unsplit(buf3);
+    buf.unsplit(buf2);
+    assert_eq!(b"aaaabbbbccccdddd", &buf[..]);
+}
+
+#[test]
+fn bytes_unsplit_overlapping_references() {
+    let mut buf = Bytes::with_capacity(64);
+    buf.extend_from_slice(b"abcdefghijklmnopqrstuvwxyz");
+    let mut buf0010 = buf.slice(0..10);
+    let buf1020 = buf.slice(10..20);
+    let buf0515 = buf.slice(5..15);
+    buf0010.unsplit(buf1020);
+    assert_eq!(b"abcdefghijklmnopqrst", &buf0010[..]);
+    assert_eq!(b"fghijklmno", &buf0515[..]);
+}
+*/
+
+#[test]
+fn bytes_mut_unsplit_basic() {
+    let mut buf = BytesMut::with_capacity(64);
+    buf.extend_from_slice(b"aaabbbcccddd");
+
+    let splitted = buf.split_off(6);
+    assert_eq!(b"aaabbb", &buf[..]);
+    assert_eq!(b"cccddd", &splitted[..]);
+
+    buf.unsplit(splitted);
+    assert_eq!(b"aaabbbcccddd", &buf[..]);
+}
+
+#[test]
+fn bytes_mut_unsplit_empty_other() {
+    let mut buf = BytesMut::with_capacity(64);
+    buf.extend_from_slice(b"aaabbbcccddd");
+
+    // empty other
+    let other = BytesMut::new();
+
+    buf.unsplit(other);
+    assert_eq!(b"aaabbbcccddd", &buf[..]);
+}
+
+#[test]
+fn bytes_mut_unsplit_empty_self() {
+    // empty self
+    let mut buf = BytesMut::new();
+
+    let mut other = BytesMut::with_capacity(64);
+    other.extend_from_slice(b"aaabbbcccddd");
+
+    buf.unsplit(other);
+    assert_eq!(b"aaabbbcccddd", &buf[..]);
+}
+
+#[test]
+fn bytes_mut_unsplit_arc_different() {
+    let mut buf = BytesMut::with_capacity(64);
+    buf.extend_from_slice(b"aaaabbbbeeee");
+
+    buf.split_off(8); //arc
+
+    let mut buf2 = BytesMut::with_capacity(64);
+    buf2.extend_from_slice(b"ccccddddeeee");
+
+    buf2.split_off(8); //arc
+
+    buf.unsplit(buf2);
+    assert_eq!(b"aaaabbbbccccdddd", &buf[..]);
+}
+
+#[test]
+fn bytes_mut_unsplit_arc_non_contiguous() {
+    let mut buf = BytesMut::with_capacity(64);
+    buf.extend_from_slice(b"aaaabbbbeeeeccccdddd");
+
+    let mut buf2 = buf.split_off(8); //arc
+
+    let buf3 = buf2.split_off(4); //arc
+
+    buf.unsplit(buf3);
+    assert_eq!(b"aaaabbbbccccdddd", &buf[..]);
+}
+
+#[test]
+fn bytes_mut_unsplit_two_split_offs() {
+    let mut buf = BytesMut::with_capacity(64);
+    buf.extend_from_slice(b"aaaabbbbccccdddd");
+
+    let mut buf2 = buf.split_off(8); //arc
+    let buf3 = buf2.split_off(4); //arc
+
+    buf2.unsplit(buf3);
+    buf.unsplit(buf2);
+    assert_eq!(b"aaaabbbbccccdddd", &buf[..]);
+}
+
+#[test]
+fn from_iter_no_size_hint() {
+    use std::iter;
+
+    let mut expect = vec![];
+
+    let actual: Bytes = iter::repeat(b'x')
+        .scan(100, |cnt, item| {
+            if *cnt >= 1 {
+                *cnt -= 1;
+                expect.push(item);
+                Some(item)
+            } else {
+                None
+            }
+        })
+        .collect();
+
+    assert_eq!(&actual[..], &expect[..]);
+}
+
+fn test_slice_ref(bytes: &Bytes, start: usize, end: usize, expected: &[u8]) {
+    let slice = &(bytes.as_ref()[start..end]);
+    let sub = bytes.slice_ref(&slice);
+    assert_eq!(&sub[..], expected);
+}
+
+#[test]
+fn slice_ref_works() {
+    let bytes = Bytes::from(&b"012345678"[..]);
+
+    test_slice_ref(&bytes, 0, 0, b"");
+    test_slice_ref(&bytes, 0, 3, b"012");
+    test_slice_ref(&bytes, 2, 6, b"2345");
+    test_slice_ref(&bytes, 7, 9, b"78");
+    test_slice_ref(&bytes, 9, 9, b"");
+}
+
+
+#[test]
+fn slice_ref_empty() {
+    let bytes = Bytes::from(&b""[..]);
+    let slice = &(bytes.as_ref()[0..0]);
+
+    let sub = bytes.slice_ref(&slice);
+    assert_eq!(&sub[..], b"");
+}
+
+#[test]
+#[should_panic]
+fn slice_ref_catches_not_a_subset() {
+    let bytes = Bytes::from(&b"012345678"[..]);
+    let slice = &b"012345"[0..4];
+
+    bytes.slice_ref(slice);
+}
+
+#[test]
+#[should_panic]
+fn slice_ref_catches_not_an_empty_subset() {
+    let bytes = Bytes::from(&b"012345678"[..]);
+    let slice = &b""[0..0];
+
+    bytes.slice_ref(slice);
+}
+
+#[test]
+#[should_panic]
+fn empty_slice_ref_catches_not_an_empty_subset() {
+    let bytes = Bytes::copy_from_slice(&b""[..]);
+    let slice = &b""[0..0];
+
+    bytes.slice_ref(slice);
+}
+
+#[test]
+fn bytes_buf_mut_advance() {
+    let mut bytes = BytesMut::with_capacity(1024);
+
+    unsafe {
+        let ptr = bytes.bytes_mut().as_ptr();
+        assert_eq!(1024, bytes.bytes_mut().len());
+
+        bytes.advance_mut(10);
+
+        let next = bytes.bytes_mut().as_ptr();
+        assert_eq!(1024 - 10, bytes.bytes_mut().len());
+        assert_eq!(ptr.offset(10), next);
+
+        // advance to the end
+        bytes.advance_mut(1024 - 10);
+
+        // The buffer size is doubled
+        assert_eq!(1024, bytes.bytes_mut().len());
+    }
+}
+
+#[test]
+#[should_panic]
+fn bytes_reserve_overflow() {
+    let mut bytes = BytesMut::with_capacity(1024);
+    bytes.put_slice(b"hello world");
+
+    bytes.reserve(usize::MAX);
+}

tests/test_chain.rs

@@ -0,0 +1,133 @@
+#![deny(warnings, rust_2018_idioms)]
+
+use bytes::{Buf, BufMut, Bytes};
+use bytes::buf::{BufExt, BufMutExt};
+use std::io::IoSlice;
+
+#[test]
+fn collect_two_bufs() {
+    let a = Bytes::from(&b"hello"[..]);
+    let b = Bytes::from(&b"world"[..]);
+
+    let res = a.chain(b).to_bytes();
+    assert_eq!(res, &b"helloworld"[..]);
+}
+
+#[test]
+fn writing_chained() {
+    let mut a = [0u8; 64];
+    let mut b = [0u8; 64];
+
+    {
+        let mut buf = (&mut a[..]).chain_mut(&mut b[..]);
+
+        for i in 0u8..128 {
+            buf.put_u8(i);
+        }
+    }
+
+    for i in 0..64 {
+        let expect = i as u8;
+        assert_eq!(expect, a[i]);
+        assert_eq!(expect + 64, b[i]);
+    }
+}
+
+#[test]
+fn iterating_two_bufs() {
+    let a = Bytes::from(&b"hello"[..]);
+    let b = Bytes::from(&b"world"[..]);
+
+    let res: Vec<u8> = a.chain(b).into_iter().collect();
+    assert_eq!(res, &b"helloworld"[..]);
+}
+
+#[test]
+fn vectored_read() {
+    let a = Bytes::from(&b"hello"[..]);
+    let b = Bytes::from(&b"world"[..]);
+
+    let mut buf = a.chain(b);
+
+    {
+        let b1: &[u8] = &mut [];
+        let b2: &[u8] = &mut [];
+        let b3: &[u8] = &mut [];
+        let b4: &[u8] = &mut [];
+        let mut iovecs = [
+            IoSlice::new(b1),
+            IoSlice::new(b2),
+            IoSlice::new(b3),
+            IoSlice::new(b4),
+        ];
+
+        assert_eq!(2, buf.bytes_vectored(&mut iovecs));
+        assert_eq!(iovecs[0][..], b"hello"[..]);
+        assert_eq!(iovecs[1][..], b"world"[..]);
+        assert_eq!(iovecs[2][..], b""[..]);
+        assert_eq!(iovecs[3][..], b""[..]);
+    }
+
+    buf.advance(2);
+
+    {
+        let b1: &[u8] = &mut [];
+        let b2: &[u8] = &mut [];
+        let b3: &[u8] = &mut [];
+        let b4: &[u8] = &mut [];
+        let mut iovecs = [
+            IoSlice::new(b1),
+            IoSlice::new(b2),
+            IoSlice::new(b3),
+            IoSlice::new(b4),
+        ];
+
+        assert_eq!(2, buf.bytes_vectored(&mut iovecs));
+        assert_eq!(iovecs[0][..], b"llo"[..]);
+        assert_eq!(iovecs[1][..], b"world"[..]);
+        assert_eq!(iovecs[2][..], b""[..]);
+        assert_eq!(iovecs[3][..], b""[..]);
+    }
+
+    buf.advance(3);
+
+    {
+        let b1: &[u8] = &mut [];
+        let b2: &[u8] = &mut [];
+        let b3: &[u8] = &mut [];
+        let b4: &[u8] = &mut [];
+        let mut iovecs = [
+            IoSlice::new(b1),
+            IoSlice::new(b2),
+            IoSlice::new(b3),
+            IoSlice::new(b4),
+        ];
+
+        assert_eq!(1, buf.bytes_vectored(&mut iovecs));
+        assert_eq!(iovecs[0][..], b"world"[..]);
+        assert_eq!(iovecs[1][..], b""[..]);
+        assert_eq!(iovecs[2][..], b""[..]);
+        assert_eq!(iovecs[3][..], b""[..]);
+    }
+
+    buf.advance(3);
+
+    {
+        let b1: &[u8] = &mut [];
+        let b2: &[u8] = &mut [];
+        let b3: &[u8] = &mut [];
+        let b4: &[u8] = &mut [];
+        let mut iovecs = [
+            IoSlice::new(b1),
+            IoSlice::new(b2),
+            IoSlice::new(b3),
+            IoSlice::new(b4),
+        ];
+
+        assert_eq!(1, buf.bytes_vectored(&mut iovecs));
+        assert_eq!(iovecs[0][..], b"ld"[..]);
+        assert_eq!(iovecs[1][..], b""[..]);
+        assert_eq!(iovecs[2][..], b""[..]);
+        assert_eq!(iovecs[3][..], b""[..]);
+    }
+}

tests/test_debug.rs

@@ -0,0 +1,35 @@
+#![deny(warnings, rust_2018_idioms)]
+
+use bytes::Bytes;
+
+#[test]
+fn fmt() {
+    let vec: Vec<_> = (0..0x100).map(|b| b as u8).collect();
+
+    let expected = "b\"\
+        \\0\\x01\\x02\\x03\\x04\\x05\\x06\\x07\
+        \\x08\\t\\n\\x0b\\x0c\\r\\x0e\\x0f\
+        \\x10\\x11\\x12\\x13\\x14\\x15\\x16\\x17\
+        \\x18\\x19\\x1a\\x1b\\x1c\\x1d\\x1e\\x1f\
+        \x20!\\\"#$%&'()*+,-./0123456789:;<=>?\
+        @ABCDEFGHIJKLMNOPQRSTUVWXYZ[\\\\]^_\
+        `abcdefghijklmnopqrstuvwxyz{|}~\\x7f\
+        \\x80\\x81\\x82\\x83\\x84\\x85\\x86\\x87\
+        \\x88\\x89\\x8a\\x8b\\x8c\\x8d\\x8e\\x8f\
+        \\x90\\x91\\x92\\x93\\x94\\x95\\x96\\x97\
+        \\x98\\x99\\x9a\\x9b\\x9c\\x9d\\x9e\\x9f\
+        \\xa0\\xa1\\xa2\\xa3\\xa4\\xa5\\xa6\\xa7\
+        \\xa8\\xa9\\xaa\\xab\\xac\\xad\\xae\\xaf\
+        \\xb0\\xb1\\xb2\\xb3\\xb4\\xb5\\xb6\\xb7\
+        \\xb8\\xb9\\xba\\xbb\\xbc\\xbd\\xbe\\xbf\
+        \\xc0\\xc1\\xc2\\xc3\\xc4\\xc5\\xc6\\xc7\
+        \\xc8\\xc9\\xca\\xcb\\xcc\\xcd\\xce\\xcf\
+        \\xd0\\xd1\\xd2\\xd3\\xd4\\xd5\\xd6\\xd7\
+        \\xd8\\xd9\\xda\\xdb\\xdc\\xdd\\xde\\xdf\
+        \\xe0\\xe1\\xe2\\xe3\\xe4\\xe5\\xe6\\xe7\
+        \\xe8\\xe9\\xea\\xeb\\xec\\xed\\xee\\xef\
+        \\xf0\\xf1\\xf2\\xf3\\xf4\\xf5\\xf6\\xf7\
+        \\xf8\\xf9\\xfa\\xfb\\xfc\\xfd\\xfe\\xff\"";
+
+    assert_eq!(expected, format!("{:?}", Bytes::from(vec)));
+}

tests/test_iter.rs

@@ -0,0 +1,22 @@
+#![deny(warnings, rust_2018_idioms)]
+
+use bytes::Bytes;
+
+#[test]
+fn iter_len() {
+    let buf = Bytes::from_static(b"hello world");
+    let iter = buf.iter();
+
+    assert_eq!(iter.size_hint(), (11, Some(11)));
+    assert_eq!(iter.len(), 11);
+}
+
+
+#[test]
+fn empty_iter_len() {
+    let buf = Bytes::from_static(b"");
+    let iter = buf.iter();
+
+    assert_eq!(iter.size_hint(), (0, Some(0)));
+    assert_eq!(iter.len(), 0);
+}

tests/test_reader.rs

@@ -0,0 +1,28 @@
+#![deny(warnings, rust_2018_idioms)]
+
+use std::io::{BufRead, Read};
+
+use bytes::buf::{BufExt};
+
+#[test]
+fn read() {
+    let buf1 = &b"hello "[..];
+    let buf2 = &b"world"[..];
+    let buf = BufExt::chain(buf1, buf2); // Disambiguate with Read::chain
+    let mut buffer = Vec::new();
+    buf.reader().read_to_end(&mut buffer).unwrap();
+    assert_eq!(b"hello world", &buffer[..]);
+}
+
+#[test]
+fn buf_read() {
+    let buf1 = &b"hell"[..];
+    let buf2 = &b"o\nworld"[..];
+    let mut reader = BufExt::chain(buf1, buf2).reader();
+    let mut line = String::new();
+    reader.read_line(&mut line).unwrap();
+    assert_eq!("hello\n", &line);
+    line.clear();
+    reader.read_line(&mut line).unwrap();
+    assert_eq!("world", &line);
+}

tests/test_serde.rs

@@ -0,0 +1,20 @@
+#![cfg(feature = "serde")]
+#![deny(warnings, rust_2018_idioms)]
+
+use serde_test::{Token, assert_tokens};
+
+#[test]
+fn test_ser_de_empty() {
+    let b = bytes::Bytes::new();
+    assert_tokens(&b, &[Token::Bytes(b"")]);
+    let b = bytes::BytesMut::with_capacity(0);
+    assert_tokens(&b, &[Token::Bytes(b"")]);
+}
+
+#[test]
+fn test_ser_de() {
+    let b = bytes::Bytes::from(&b"bytes"[..]);
+    assert_tokens(&b, &[Token::Bytes(b"bytes")]);
+    let b = bytes::BytesMut::from(&b"bytes"[..]);
+    assert_tokens(&b, &[Token::Bytes(b"bytes")]);
+}

tests/test_take.rs

@@ -0,0 +1,12 @@
+#![deny(warnings, rust_2018_idioms)]
+
+use bytes::buf::{Buf, BufExt};
+
+#[test]
+fn long_take() {
+    // Tests that get a take with a size greater than the buffer length will not
+    // overrun the buffer. Regression test for #138.
+    let buf = b"hello world".take(100);
+    assert_eq!(11, buf.remaining());
+    assert_eq!(b"hello world", buf.bytes());
+}