mirror of
https://github.com/tokio-rs/bytes.git
synced 2026-08-08 00:00:26 +02:00
Compare commits
1
Commits
| Author | SHA1 | Date | |
|---|---|---|---|
 Artem Vorotnikov
|
2a66700a94 |
+33
-50
@@ -7,13 +7,10 @@ on:
|
||||
push:
|
||||
branches:
|
||||
- master
|
||||
schedule:
|
||||
- cron: '0 2 * * 0'
|
||||
|
||||
env:
|
||||
RUSTFLAGS: -Dwarnings
|
||||
RUST_BACKTRACE: 1
|
||||
nightly: nightly-2024-09-15
|
||||
|
||||
defaults:
|
||||
run:
|
||||
@@ -25,11 +22,11 @@ jobs:
|
||||
name: rustfmt
|
||||
runs-on: ubuntu-latest
|
||||
steps:
|
||||
- uses: actions/checkout@v4
|
||||
- uses: actions/checkout@v2
|
||||
- name: Install Rust
|
||||
run: rustup update stable
|
||||
run: rustup update stable && rustup default stable
|
||||
- name: Check formatting
|
||||
run: cargo fmt --all --check
|
||||
run: cargo fmt --all -- --check
|
||||
|
||||
# TODO
|
||||
# # Apply clippy lints
|
||||
@@ -37,7 +34,7 @@ jobs:
|
||||
# name: clippy
|
||||
# runs-on: ubuntu-latest
|
||||
# steps:
|
||||
# - uses: actions/checkout@v4
|
||||
# - uses: actions/checkout@v2
|
||||
# - name: Apply clippy lints
|
||||
# run: cargo clippy --all-features
|
||||
|
||||
@@ -50,11 +47,11 @@ jobs:
|
||||
name: minrust
|
||||
runs-on: ubuntu-latest
|
||||
steps:
|
||||
- uses: actions/checkout@v4
|
||||
- name: Install cargo-hack
|
||||
uses: taiki-e/install-action@cargo-hack
|
||||
- uses: actions/checkout@v2
|
||||
- name: Install Rust
|
||||
run: rustup update 1.39.0 && rustup default 1.39.0
|
||||
- name: Check
|
||||
run: cargo hack check --feature-powerset --optional-deps --rust-version
|
||||
run: . ci/test-stable.sh check
|
||||
|
||||
# Stable
|
||||
stable:
|
||||
@@ -67,27 +64,26 @@ jobs:
|
||||
- windows-latest
|
||||
runs-on: ${{ matrix.os }}
|
||||
steps:
|
||||
- uses: actions/checkout@v4
|
||||
- uses: actions/checkout@v2
|
||||
- name: Install Rust
|
||||
# --no-self-update is necessary because the windows environment cannot self-update rustup.exe.
|
||||
run: rustup update stable --no-self-update
|
||||
- name: Install cargo-hack
|
||||
uses: taiki-e/install-action@cargo-hack
|
||||
run: rustup update stable --no-self-update && rustup default stable
|
||||
- name: Test
|
||||
run: ci/test-stable.sh test
|
||||
run: . ci/test-stable.sh test
|
||||
|
||||
# Nightly
|
||||
nightly:
|
||||
name: nightly
|
||||
env:
|
||||
# Pin nightly to avoid being impacted by breakage
|
||||
RUST_VERSION: nightly-2019-09-25
|
||||
runs-on: ubuntu-latest
|
||||
steps:
|
||||
- uses: actions/checkout@v4
|
||||
- uses: actions/checkout@v2
|
||||
- name: Install Rust
|
||||
run: rustup update $nightly && rustup default $nightly
|
||||
- name: Install cargo-hack
|
||||
uses: taiki-e/install-action@cargo-hack
|
||||
run: rustup update $RUST_VERSION && rustup default $RUST_VERSION
|
||||
- name: Test
|
||||
run: ci/test-stable.sh test
|
||||
run: . ci/test-stable.sh test
|
||||
|
||||
# Run tests on some extra platforms
|
||||
cross:
|
||||
@@ -100,16 +96,15 @@ jobs:
|
||||
- powerpc-unknown-linux-gnu
|
||||
- powerpc64-unknown-linux-gnu
|
||||
- wasm32-unknown-unknown
|
||||
runs-on: ubuntu-latest
|
||||
runs-on: ubuntu-16.04
|
||||
steps:
|
||||
- uses: actions/checkout@v4
|
||||
- uses: actions/checkout@v2
|
||||
- name: Install Rust
|
||||
run: rustup update stable
|
||||
- name: Install cross
|
||||
uses: taiki-e/install-action@cross
|
||||
if: matrix.target != 'wasm32-unknown-unknown'
|
||||
run: rustup update stable && rustup default stable
|
||||
- name: cross build --target ${{ matrix.target }}
|
||||
run: cross build --target ${{ matrix.target }}
|
||||
run: |
|
||||
cargo install cross
|
||||
cross build --target ${{ matrix.target }}
|
||||
if: matrix.target != 'wasm32-unknown-unknown'
|
||||
# WASM support
|
||||
- name: cargo build --target ${{ matrix.target }}
|
||||
@@ -123,32 +118,25 @@ jobs:
|
||||
name: tsan
|
||||
runs-on: ubuntu-latest
|
||||
steps:
|
||||
- uses: actions/checkout@v4
|
||||
- uses: actions/checkout@v2
|
||||
- name: Install Rust
|
||||
run: rustup update $nightly && rustup default $nightly
|
||||
run: rustup update nightly && rustup default nightly
|
||||
- name: Install rust-src
|
||||
run: rustup component add rust-src
|
||||
- name: ASAN / TSAN
|
||||
run: ci/tsan.sh
|
||||
|
||||
miri:
|
||||
name: miri
|
||||
runs-on: ubuntu-latest
|
||||
steps:
|
||||
- uses: actions/checkout@v4
|
||||
- name: Install Rust
|
||||
run: rustup update $nightly && rustup default $nightly
|
||||
- name: Miri
|
||||
run: ci/miri.sh
|
||||
run: . ci/tsan.sh
|
||||
|
||||
# Loom
|
||||
loom:
|
||||
name: loom
|
||||
env:
|
||||
# Pin nightly to avoid being impacted by breakage
|
||||
RUST_VERSION: nightly-2020-05-19
|
||||
runs-on: ubuntu-latest
|
||||
steps:
|
||||
- uses: actions/checkout@v4
|
||||
- uses: actions/checkout@v2
|
||||
- name: Install Rust
|
||||
run: rustup update $nightly && rustup default $nightly
|
||||
run: rustup update $RUST_VERSION && rustup default $RUST_VERSION
|
||||
- name: Loom tests
|
||||
run: RUSTFLAGS="--cfg loom -Dwarnings" cargo test --lib
|
||||
|
||||
@@ -161,18 +149,13 @@ jobs:
|
||||
- nightly
|
||||
- minrust
|
||||
- cross
|
||||
- tsan
|
||||
- miri
|
||||
- loom
|
||||
runs-on: ubuntu-latest
|
||||
steps:
|
||||
- uses: actions/checkout@v4
|
||||
- uses: actions/checkout@v2
|
||||
- name: Install Rust
|
||||
run: rustup update $nightly && rustup default $nightly
|
||||
run: rustup update stable && rustup default stable
|
||||
- name: Build documentation
|
||||
run: cargo doc --no-deps --all-features
|
||||
env:
|
||||
RUSTDOCFLAGS: --cfg docsrs
|
||||
- name: Publish documentation
|
||||
run: |
|
||||
cd target/doc
|
||||
|
||||
-209
@@ -1,212 +1,3 @@
|
||||
# 1.8.0 (October 21, 2024)
|
||||
|
||||
- Guarantee address in `split_off`/`split_to` for empty slices (#740)
|
||||
|
||||
# 1.7.2 (September 17, 2024)
|
||||
|
||||
### Fixed
|
||||
|
||||
- Fix default impl of `Buf::{get_int, get_int_le}` (#732)
|
||||
|
||||
### Documented
|
||||
|
||||
- Fix double spaces in comments and doc comments (#731)
|
||||
|
||||
### Internal changes
|
||||
|
||||
- Ensure BytesMut::advance reduces capacity (#728)
|
||||
|
||||
# 1.7.1 (August 1, 2024)
|
||||
|
||||
This release reverts the following change due to a regression:
|
||||
|
||||
- Reuse capacity when possible in `<BytesMut as Buf>::advance` impl (#698)
|
||||
|
||||
The revert can be found at #726.
|
||||
|
||||
# 1.7.0 (July 31, 2024)
|
||||
|
||||
### Added
|
||||
|
||||
- Add conversion from `Bytes` to `BytesMut` (#695, #710)
|
||||
- Add reclaim method without additional allocation (#686)
|
||||
|
||||
### Documented
|
||||
|
||||
- Clarify how `BytesMut::zeroed` works (#714)
|
||||
- Clarify the behavior of `Buf::chunk` (#717)
|
||||
|
||||
### Changed
|
||||
|
||||
- Change length condition of `BytesMut::truncate`
|
||||
- Reuse capacity when possible in `<BytesMut as Buf>::advance` impl (#698)
|
||||
- Improve `must_use` suggestion of `BytesMut::split` (#699)
|
||||
|
||||
### Internal changes
|
||||
|
||||
- Use `ManuallyDrop` instead of `mem::forget` (#678)
|
||||
- Don't set `len` in `BytesMut::reserve` (#682)
|
||||
- Optimize `Bytes::copy_to_bytes` (#688)
|
||||
- Refactor `BytesMut::truncate` (#694)
|
||||
- Refactor `BytesMut::resize` (#696)
|
||||
- Reorder assertion in `Bytes::split_to`, `Bytes::split_off` (#689, #693)
|
||||
- Use `offset_from` in more places (#705)
|
||||
- Correct the wrong usage of `IntoIter` (#707)
|
||||
|
||||
# 1.6.1 (July 13, 2024)
|
||||
|
||||
This release fixes a bug where `Bytes::is_unique` returns incorrect values when
|
||||
the `Bytes` originates from a shared `BytesMut`. (#718)
|
||||
|
||||
# 1.6.0 (March 22, 2024)
|
||||
|
||||
### Added
|
||||
|
||||
- Add `Bytes::is_unique` (#643)
|
||||
|
||||
### Documented
|
||||
|
||||
- Fix changelog typo (#628)
|
||||
- Fix some spelling mistakes (#633)
|
||||
- Typo fix (#637)
|
||||
- Fix broken links (#639)
|
||||
- Add security policy (#649)
|
||||
|
||||
### Internal changes
|
||||
|
||||
- Move comment to correct constant (#629)
|
||||
- Various cleanup (#635)
|
||||
- Simplify `UninitSlice::as_uninit_slice_mut()` logic (#644)
|
||||
- Use `self.` instead of `Self::` (#642)
|
||||
- `BytesMut`: Assert alignment of `Shared` (#652)
|
||||
- Remove unnecessary namespace qualifier (#660)
|
||||
- Remove an unnecessary else branch (#662)
|
||||
- Remove unreachable else branch (#661)
|
||||
- make parameter mut in `From<Vec>` (#667)
|
||||
- Restore commented tests (#665)
|
||||
- Use `sub` instead of `offset` (#668)
|
||||
- Calculate original capacity only if necessary (#666)
|
||||
- `set_vec_pos` does not need a second parameter (#672)
|
||||
- `get_vec_pos`: use `&self` instead of `&mut self` (#670)
|
||||
- Refactor `split_at`/`split_to` (#663)
|
||||
- Use `Iterator` from the prelude (#673)
|
||||
- `copy_to_bytes`: Add panic section to docs (#676)
|
||||
- Remove redundant reserve call (#674)
|
||||
- Use `ManuallyDrop` instead of `mem::forget` (#675)
|
||||
|
||||
|
||||
# 1.5.0 (September 7, 2023)
|
||||
|
||||
### Added
|
||||
|
||||
- Add `UninitSlice::{new,uninit}` (#598, #599)
|
||||
- Implement `BufMut` for `&mut [MaybeUninit<u8>]` (#597)
|
||||
|
||||
### Changed
|
||||
|
||||
- Mark `BytesMut::extend_from_slice` as inline (#595)
|
||||
|
||||
# 1.4.0 (January 31, 2023)
|
||||
|
||||
### Added
|
||||
|
||||
- Make `IntoIter` constructor public (#581)
|
||||
|
||||
### Fixed
|
||||
|
||||
- Avoid large reallocations when freezing `BytesMut` (#592)
|
||||
|
||||
### Documented
|
||||
|
||||
- Document which functions require `std` (#591)
|
||||
- Fix duplicate "the the" typos (#585)
|
||||
|
||||
# 1.3.0 (November 20, 2022)
|
||||
|
||||
### Added
|
||||
|
||||
- Rename and expose `BytesMut::spare_capacity_mut` (#572)
|
||||
- Implement native-endian get and put functions for `Buf` and `BufMut` (#576)
|
||||
|
||||
### Fixed
|
||||
|
||||
- Don't have important data in unused capacity when calling reserve (#563)
|
||||
|
||||
### Documented
|
||||
|
||||
- `Bytes::new` etc should return `Self` not `Bytes` (#568)
|
||||
|
||||
# 1.2.1 (July 30, 2022)
|
||||
|
||||
### Fixed
|
||||
|
||||
- Fix unbounded memory growth when using `reserve` (#560)
|
||||
|
||||
# 1.2.0 (July 19, 2022)
|
||||
|
||||
### Added
|
||||
|
||||
- Add `BytesMut::zeroed` (#517)
|
||||
- Implement `Extend<Bytes>` for `BytesMut` (#527)
|
||||
- Add conversion from `BytesMut` to `Vec<u8>` (#543, #554)
|
||||
- Add conversion from `Bytes` to `Vec<u8>` (#547)
|
||||
- Add `UninitSlice::as_uninit_slice_mut()` (#548)
|
||||
- Add const to `Bytes::{len,is_empty}` (#514)
|
||||
|
||||
### Changed
|
||||
|
||||
- Reuse vector in `BytesMut::reserve` (#539, #544)
|
||||
|
||||
### Fixed
|
||||
|
||||
- Make miri happy (#515, #523, #542, #545, #553)
|
||||
- Make tsan happy (#541)
|
||||
- Fix `remaining_mut()` on chain (#488)
|
||||
- Fix amortized asymptotics of `BytesMut` (#555)
|
||||
|
||||
### Documented
|
||||
|
||||
- Redraw layout diagram with box drawing characters (#539)
|
||||
- Clarify `BytesMut::unsplit` docs (#535)
|
||||
|
||||
# 1.1.0 (August 25, 2021)
|
||||
|
||||
### Added
|
||||
|
||||
- `BufMut::put_bytes(self, val, cnt)` (#487)
|
||||
- Implement `From<Box<[u8]>>` for `Bytes` (#504)
|
||||
|
||||
### Changed
|
||||
|
||||
- Override `put_slice` for `&mut [u8]` (#483)
|
||||
- Panic on integer overflow in `Chain::remaining` (#482)
|
||||
- Add inline tags to `UninitSlice` methods (#443)
|
||||
- Override `copy_to_bytes` for Chain and Take (#481)
|
||||
- Keep capacity when unsplit on empty other buf (#502)
|
||||
|
||||
### Documented
|
||||
|
||||
- Clarify `BufMut` allocation guarantees (#501)
|
||||
- Clarify `BufMut::put_int` behavior (#486)
|
||||
- Clarify actions of `clear` and `truncate`. (#508)
|
||||
|
||||
# 1.0.1 (January 11, 2021)
|
||||
|
||||
### Changed
|
||||
- mark `Vec::put_slice` with `#[inline]` (#459)
|
||||
|
||||
### Fixed
|
||||
- Fix deprecation warning (#457)
|
||||
- use `Box::into_raw` instead of `mem::forget`-in-disguise (#458)
|
||||
|
||||
# 1.0.0 (December 22, 2020)
|
||||
|
||||
### Changed
|
||||
- Rename `Buf`/`BufMut` methods `bytes()` and `bytes_mut()` to `chunk()` and `chunk_mut()` (#450)
|
||||
|
||||
### Removed
|
||||
- remove unused Buf implementation. (#449)
|
||||
|
||||
# 0.6.0 (October 21, 2020)
|
||||
|
||||
API polish in preparation for a 1.0 release.
|
||||
|
||||
+7
-8
@@ -2,21 +2,23 @@
|
||||
|
||||
name = "bytes"
|
||||
# When releasing to crates.io:
|
||||
# - Update html_root_url.
|
||||
# - Update CHANGELOG.md.
|
||||
# - Create "v1.x.y" git tag.
|
||||
version = "1.8.0"
|
||||
edition = "2018"
|
||||
rust-version = "1.39"
|
||||
# - Update doc URL.
|
||||
# - Create "v0.6.x" git tag.
|
||||
version = "0.6.0"
|
||||
license = "MIT"
|
||||
authors = [
|
||||
"Carl Lerche <[email protected]>",
|
||||
"Sean McArthur <[email protected]>",
|
||||
]
|
||||
description = "Types and traits for working with bytes"
|
||||
documentation = "https://docs.rs/bytes/0.6.0/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"]
|
||||
@@ -29,7 +31,4 @@ serde = { version = "1.0.60", optional = true, default-features = false, feature
|
||||
serde_test = "1.0"
|
||||
|
||||
[target.'cfg(loom)'.dev-dependencies]
|
||||
loom = "0.7"
|
||||
|
||||
[package.metadata.docs.rs]
|
||||
rustdoc-args = ["--cfg", "docsrs"]
|
||||
loom = "0.3"
|
||||
|
||||
@@ -18,7 +18,7 @@ To use `bytes`, first add this to your `Cargo.toml`:
|
||||
|
||||
```toml
|
||||
[dependencies]
|
||||
bytes = "1"
|
||||
bytes = "0.6"
|
||||
```
|
||||
|
||||
Next, add this to your crate:
|
||||
@@ -33,16 +33,7 @@ Serde support is optional and disabled by default. To enable use the feature `se
|
||||
|
||||
```toml
|
||||
[dependencies]
|
||||
bytes = { version = "1", features = ["serde"] }
|
||||
```
|
||||
|
||||
## Building documentation
|
||||
|
||||
When building the `bytes` documentation the `docsrs` option should be used, otherwise
|
||||
feature gates will not be shown. This requires a nightly toolchain:
|
||||
|
||||
```
|
||||
RUSTDOCFLAGS="--cfg docsrs" cargo +nightly doc
|
||||
bytes = { version = "0.6", features = ["serde"] }
|
||||
```
|
||||
|
||||
## License
|
||||
|
||||
@@ -1,9 +0,0 @@
|
||||
# Security Policy
|
||||
|
||||
Bytes is part of the Tokio project and uses the same security policy as [Tokio][tokio-security].
|
||||
|
||||
## Report a security issue
|
||||
|
||||
The process for reporting an issue is the same as for [Tokio][tokio-security]. This includes private reporting via security@tokio.rs.
|
||||
|
||||
[tokio-security]: https://github.com/tokio-rs/tokio/security/policy
|
||||
+5
-4
@@ -46,14 +46,14 @@ impl TestBuf {
|
||||
}
|
||||
impl Buf for TestBuf {
|
||||
fn remaining(&self) -> usize {
|
||||
self.buf.len() - self.pos
|
||||
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 chunk(&self) -> &[u8] {
|
||||
fn bytes(&self) -> &[u8] {
|
||||
if self.readlen == 0 {
|
||||
Default::default()
|
||||
} else {
|
||||
@@ -87,8 +87,8 @@ impl Buf for TestBufC {
|
||||
self.inner.advance(cnt)
|
||||
}
|
||||
#[inline(never)]
|
||||
fn chunk(&self) -> &[u8] {
|
||||
self.inner.chunk()
|
||||
fn bytes(&self) -> &[u8] {
|
||||
self.inner.bytes()
|
||||
}
|
||||
}
|
||||
|
||||
@@ -159,6 +159,7 @@ macro_rules! bench_group {
|
||||
mod get_u8 {
|
||||
use super::*;
|
||||
bench_group!(get_u8);
|
||||
bench!(option, option);
|
||||
}
|
||||
mod get_u16 {
|
||||
use super::*;
|
||||
|
||||
+3
-4
@@ -47,7 +47,7 @@ fn clone_static(b: &mut Bencher) {
|
||||
|
||||
b.iter(|| {
|
||||
for _ in 0..1024 {
|
||||
test::black_box(test::black_box(&bytes).clone());
|
||||
test::black_box(&bytes.clone());
|
||||
}
|
||||
})
|
||||
}
|
||||
@@ -58,7 +58,7 @@ fn clone_shared(b: &mut Bencher) {
|
||||
|
||||
b.iter(|| {
|
||||
for _ in 0..1024 {
|
||||
test::black_box(test::black_box(&bytes).clone());
|
||||
test::black_box(&bytes.clone());
|
||||
}
|
||||
})
|
||||
}
|
||||
@@ -70,7 +70,7 @@ fn clone_arc_vec(b: &mut Bencher) {
|
||||
|
||||
b.iter(|| {
|
||||
for _ in 0..1024 {
|
||||
test::black_box(test::black_box(&bytes).clone());
|
||||
test::black_box(&bytes.clone());
|
||||
}
|
||||
})
|
||||
}
|
||||
@@ -88,7 +88,6 @@ fn from_long_slice(b: &mut Bencher) {
|
||||
#[bench]
|
||||
fn slice_empty(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(i % 100..i % 100));
|
||||
|
||||
-10
@@ -1,10 +0,0 @@
|
||||
#!/bin/bash
|
||||
set -e
|
||||
|
||||
rustup component add miri
|
||||
cargo miri setup
|
||||
|
||||
export MIRIFLAGS="-Zmiri-strict-provenance"
|
||||
|
||||
cargo miri test
|
||||
cargo miri test --target mips64-unknown-linux-gnuabi64
|
||||
Executable → Regular
+5
@@ -4,6 +4,9 @@ set -ex
|
||||
|
||||
cmd="${1:-test}"
|
||||
|
||||
# Install cargo-hack for feature flag test
|
||||
cargo install cargo-hack
|
||||
|
||||
# Run with each feature
|
||||
# * --each-feature includes both default/no-default features
|
||||
# * --optional-deps is needed for serde feature
|
||||
@@ -11,6 +14,8 @@ cargo hack "${cmd}" --each-feature --optional-deps
|
||||
# Run with all features
|
||||
cargo "${cmd}" --all-features
|
||||
|
||||
cargo doc --no-deps --all-features
|
||||
|
||||
if [[ "${RUST_VERSION}" == "nightly"* ]]; then
|
||||
# Check benchmarks
|
||||
cargo check --benches
|
||||
|
||||
Executable → Regular
@@ -1 +0,0 @@
|
||||
msrv = "1.39"
|
||||
+107
-479
@@ -1,9 +1,8 @@
|
||||
#[cfg(feature = "std")]
|
||||
use crate::buf::{reader, Reader};
|
||||
use crate::buf::{take, Chain, Take};
|
||||
#[cfg(feature = "std")]
|
||||
use crate::{min_u64_usize, saturating_sub_usize_u64};
|
||||
use crate::{panic_advance, panic_does_not_fit};
|
||||
|
||||
use core::{cmp, mem, ptr};
|
||||
|
||||
#[cfg(feature = "std")]
|
||||
use std::io::IoSlice;
|
||||
@@ -12,17 +11,12 @@ use alloc::boxed::Box;
|
||||
|
||||
macro_rules! buf_get_impl {
|
||||
($this:ident, $typ:tt::$conv:tt) => {{
|
||||
const SIZE: usize = core::mem::size_of::<$typ>();
|
||||
|
||||
if $this.remaining() < SIZE {
|
||||
panic_advance(SIZE, $this.remaining());
|
||||
}
|
||||
|
||||
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
|
||||
.chunk()
|
||||
.bytes()
|
||||
.get(..SIZE)
|
||||
.map(|src| unsafe { $typ::$conv(*(src as *const _ as *const [_; SIZE])) });
|
||||
|
||||
@@ -38,40 +32,23 @@ macro_rules! buf_get_impl {
|
||||
}
|
||||
}};
|
||||
(le => $this:ident, $typ:tt, $len_to_read:expr) => {{
|
||||
const SIZE: usize = core::mem::size_of::<$typ>();
|
||||
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; SIZE];
|
||||
|
||||
let subslice = match buf.get_mut(..$len_to_read) {
|
||||
Some(subslice) => subslice,
|
||||
None => panic_does_not_fit(SIZE, $len_to_read),
|
||||
};
|
||||
|
||||
$this.copy_to_slice(subslice);
|
||||
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) => {{
|
||||
const SIZE: usize = core::mem::size_of::<$typ>();
|
||||
debug_assert!(mem::size_of::<$typ>() >= $len_to_read);
|
||||
|
||||
let slice_at = match SIZE.checked_sub($len_to_read) {
|
||||
Some(slice_at) => slice_at,
|
||||
None => panic_does_not_fit(SIZE, $len_to_read),
|
||||
};
|
||||
|
||||
let mut buf = [0; SIZE];
|
||||
$this.copy_to_slice(&mut buf[slice_at..]);
|
||||
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);
|
||||
}};
|
||||
}
|
||||
|
||||
// https://en.wikipedia.org/wiki/Sign_extension
|
||||
fn sign_extend(val: u64, nbytes: usize) -> i64 {
|
||||
let shift = (8 - nbytes) * 8;
|
||||
(val << shift) as i64 >> shift
|
||||
}
|
||||
|
||||
/// Read bytes from a buffer.
|
||||
///
|
||||
/// A buffer stores bytes in memory such that read operations are infallible.
|
||||
@@ -101,7 +78,7 @@ pub trait Buf {
|
||||
/// the buffer.
|
||||
///
|
||||
/// This value is greater than or equal to the length of the slice returned
|
||||
/// by `chunk()`.
|
||||
/// by `bytes`.
|
||||
///
|
||||
/// # Examples
|
||||
///
|
||||
@@ -138,36 +115,31 @@ pub trait Buf {
|
||||
///
|
||||
/// let mut buf = &b"hello world"[..];
|
||||
///
|
||||
/// assert_eq!(buf.chunk(), &b"hello world"[..]);
|
||||
/// assert_eq!(buf.bytes(), &b"hello world"[..]);
|
||||
///
|
||||
/// buf.advance(6);
|
||||
///
|
||||
/// assert_eq!(buf.chunk(), &b"world"[..]);
|
||||
/// assert_eq!(buf.bytes(), &b"world"[..]);
|
||||
/// ```
|
||||
///
|
||||
/// # Implementer notes
|
||||
///
|
||||
/// This function should never panic. `chunk()` should return an empty
|
||||
/// slice **if and only if** `remaining()` returns 0. In other words,
|
||||
/// `chunk()` returning an empty slice implies that `remaining()` will
|
||||
/// return 0 and `remaining()` returning 0 implies that `chunk()` will
|
||||
/// return an empty slice.
|
||||
// The `chunk` method was previously called `bytes`. This alias makes the rename
|
||||
// more easily discoverable.
|
||||
#[cfg_attr(docsrs, doc(alias = "bytes"))]
|
||||
fn chunk(&self) -> &[u8];
|
||||
/// 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, `chunk_vectored` enables
|
||||
/// 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 `chunk_vectored` does not fill every
|
||||
/// 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.
|
||||
///
|
||||
@@ -177,7 +149,7 @@ pub trait Buf {
|
||||
/// # Implementer notes
|
||||
///
|
||||
/// This function should never panic. Once the end of the buffer is reached,
|
||||
/// i.e., `Buf::remaining` returns 0, calls to `chunk_vectored` must return 0
|
||||
/// 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
|
||||
@@ -185,14 +157,13 @@ pub trait Buf {
|
||||
///
|
||||
/// [`writev`]: http://man7.org/linux/man-pages/man2/readv.2.html
|
||||
#[cfg(feature = "std")]
|
||||
#[cfg_attr(docsrs, doc(cfg(feature = "std")))]
|
||||
fn chunks_vectored<'a>(&'a self, dst: &mut [IoSlice<'a>]) -> usize {
|
||||
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.chunk());
|
||||
dst[0] = IoSlice::new(self.bytes());
|
||||
1
|
||||
} else {
|
||||
0
|
||||
@@ -201,7 +172,7 @@ pub trait Buf {
|
||||
|
||||
/// Advance the internal cursor of the Buf
|
||||
///
|
||||
/// The next call to `chunk()` will return a slice starting `cnt` bytes
|
||||
/// The next call to `bytes` will return a slice starting `cnt` bytes
|
||||
/// further into the underlying buffer.
|
||||
///
|
||||
/// # Examples
|
||||
@@ -211,11 +182,11 @@ pub trait Buf {
|
||||
///
|
||||
/// let mut buf = &b"hello world"[..];
|
||||
///
|
||||
/// assert_eq!(buf.chunk(), &b"hello world"[..]);
|
||||
/// assert_eq!(buf.bytes(), &b"hello world"[..]);
|
||||
///
|
||||
/// buf.advance(6);
|
||||
///
|
||||
/// assert_eq!(buf.chunk(), &b"world"[..]);
|
||||
/// assert_eq!(buf.bytes(), &b"world"[..]);
|
||||
/// ```
|
||||
///
|
||||
/// # Panics
|
||||
@@ -272,18 +243,23 @@ pub trait Buf {
|
||||
///
|
||||
/// # Panics
|
||||
///
|
||||
/// This function panics if `self.remaining() < dst.len()`.
|
||||
fn copy_to_slice(&mut self, mut dst: &mut [u8]) {
|
||||
if self.remaining() < dst.len() {
|
||||
panic_advance(dst.len(), self.remaining());
|
||||
}
|
||||
/// This function panics if `self.remaining() < dst.len()`
|
||||
fn copy_to_slice(&mut self, dst: &mut [u8]) {
|
||||
let mut off = 0;
|
||||
|
||||
while !dst.is_empty() {
|
||||
let src = self.chunk();
|
||||
let cnt = usize::min(src.len(), dst.len());
|
||||
assert!(self.remaining() >= dst.len());
|
||||
|
||||
dst[..cnt].copy_from_slice(&src[..cnt]);
|
||||
dst = &mut dst[cnt..];
|
||||
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);
|
||||
}
|
||||
@@ -306,10 +282,8 @@ pub trait Buf {
|
||||
///
|
||||
/// This function panics if there is no more remaining data in `self`.
|
||||
fn get_u8(&mut self) -> u8 {
|
||||
if self.remaining() < 1 {
|
||||
panic_advance(1, 0);
|
||||
}
|
||||
let ret = self.chunk()[0];
|
||||
assert!(self.remaining() >= 1);
|
||||
let ret = self.bytes()[0];
|
||||
self.advance(1);
|
||||
ret
|
||||
}
|
||||
@@ -331,10 +305,8 @@ pub trait Buf {
|
||||
///
|
||||
/// This function panics if there is no more remaining data in `self`.
|
||||
fn get_i8(&mut self) -> i8 {
|
||||
if self.remaining() < 1 {
|
||||
panic_advance(1, 0);
|
||||
}
|
||||
let ret = self.chunk()[0] as i8;
|
||||
assert!(self.remaining() >= 1);
|
||||
let ret = self.bytes()[0] as i8;
|
||||
self.advance(1);
|
||||
ret
|
||||
}
|
||||
@@ -379,29 +351,6 @@ pub trait Buf {
|
||||
buf_get_impl!(self, u16::from_le_bytes);
|
||||
}
|
||||
|
||||
/// Gets an unsigned 16 bit integer from `self` in native-endian byte order.
|
||||
///
|
||||
/// The current position is advanced by 2.
|
||||
///
|
||||
/// # Examples
|
||||
///
|
||||
/// ```
|
||||
/// use bytes::Buf;
|
||||
///
|
||||
/// let mut buf: &[u8] = match cfg!(target_endian = "big") {
|
||||
/// true => b"\x08\x09 hello",
|
||||
/// false => b"\x09\x08 hello",
|
||||
/// };
|
||||
/// assert_eq!(0x0809, buf.get_u16_ne());
|
||||
/// ```
|
||||
///
|
||||
/// # Panics
|
||||
///
|
||||
/// This function panics if there is not enough remaining data in `self`.
|
||||
fn get_u16_ne(&mut self) -> u16 {
|
||||
buf_get_impl!(self, u16::from_ne_bytes);
|
||||
}
|
||||
|
||||
/// Gets a signed 16 bit integer from `self` in big-endian byte order.
|
||||
///
|
||||
/// The current position is advanced by 2.
|
||||
@@ -442,29 +391,6 @@ pub trait Buf {
|
||||
buf_get_impl!(self, i16::from_le_bytes);
|
||||
}
|
||||
|
||||
/// Gets a signed 16 bit integer from `self` in native-endian byte order.
|
||||
///
|
||||
/// The current position is advanced by 2.
|
||||
///
|
||||
/// # Examples
|
||||
///
|
||||
/// ```
|
||||
/// use bytes::Buf;
|
||||
///
|
||||
/// let mut buf: &[u8] = match cfg!(target_endian = "big") {
|
||||
/// true => b"\x08\x09 hello",
|
||||
/// false => b"\x09\x08 hello",
|
||||
/// };
|
||||
/// assert_eq!(0x0809, buf.get_i16_ne());
|
||||
/// ```
|
||||
///
|
||||
/// # Panics
|
||||
///
|
||||
/// This function panics if there is not enough remaining data in `self`.
|
||||
fn get_i16_ne(&mut self) -> i16 {
|
||||
buf_get_impl!(self, i16::from_ne_bytes);
|
||||
}
|
||||
|
||||
/// Gets an unsigned 32 bit integer from `self` in the big-endian byte order.
|
||||
///
|
||||
/// The current position is advanced by 4.
|
||||
@@ -505,29 +431,6 @@ pub trait Buf {
|
||||
buf_get_impl!(self, u32::from_le_bytes);
|
||||
}
|
||||
|
||||
/// Gets an unsigned 32 bit integer from `self` in native-endian byte order.
|
||||
///
|
||||
/// The current position is advanced by 4.
|
||||
///
|
||||
/// # Examples
|
||||
///
|
||||
/// ```
|
||||
/// use bytes::Buf;
|
||||
///
|
||||
/// let mut buf: &[u8] = match cfg!(target_endian = "big") {
|
||||
/// true => b"\x08\x09\xA0\xA1 hello",
|
||||
/// false => b"\xA1\xA0\x09\x08 hello",
|
||||
/// };
|
||||
/// assert_eq!(0x0809A0A1, buf.get_u32_ne());
|
||||
/// ```
|
||||
///
|
||||
/// # Panics
|
||||
///
|
||||
/// This function panics if there is not enough remaining data in `self`.
|
||||
fn get_u32_ne(&mut self) -> u32 {
|
||||
buf_get_impl!(self, u32::from_ne_bytes);
|
||||
}
|
||||
|
||||
/// Gets a signed 32 bit integer from `self` in big-endian byte order.
|
||||
///
|
||||
/// The current position is advanced by 4.
|
||||
@@ -568,29 +471,6 @@ pub trait Buf {
|
||||
buf_get_impl!(self, i32::from_le_bytes);
|
||||
}
|
||||
|
||||
/// Gets a signed 32 bit integer from `self` in native-endian byte order.
|
||||
///
|
||||
/// The current position is advanced by 4.
|
||||
///
|
||||
/// # Examples
|
||||
///
|
||||
/// ```
|
||||
/// use bytes::Buf;
|
||||
///
|
||||
/// let mut buf: &[u8] = match cfg!(target_endian = "big") {
|
||||
/// true => b"\x08\x09\xA0\xA1 hello",
|
||||
/// false => b"\xA1\xA0\x09\x08 hello",
|
||||
/// };
|
||||
/// assert_eq!(0x0809A0A1, buf.get_i32_ne());
|
||||
/// ```
|
||||
///
|
||||
/// # Panics
|
||||
///
|
||||
/// This function panics if there is not enough remaining data in `self`.
|
||||
fn get_i32_ne(&mut self) -> i32 {
|
||||
buf_get_impl!(self, i32::from_ne_bytes);
|
||||
}
|
||||
|
||||
/// Gets an unsigned 64 bit integer from `self` in big-endian byte order.
|
||||
///
|
||||
/// The current position is advanced by 8.
|
||||
@@ -631,29 +511,6 @@ pub trait Buf {
|
||||
buf_get_impl!(self, u64::from_le_bytes);
|
||||
}
|
||||
|
||||
/// Gets an unsigned 64 bit integer from `self` in native-endian byte order.
|
||||
///
|
||||
/// The current position is advanced by 8.
|
||||
///
|
||||
/// # Examples
|
||||
///
|
||||
/// ```
|
||||
/// use bytes::Buf;
|
||||
///
|
||||
/// let mut buf: &[u8] = match cfg!(target_endian = "big") {
|
||||
/// true => b"\x01\x02\x03\x04\x05\x06\x07\x08 hello",
|
||||
/// false => b"\x08\x07\x06\x05\x04\x03\x02\x01 hello",
|
||||
/// };
|
||||
/// assert_eq!(0x0102030405060708, buf.get_u64_ne());
|
||||
/// ```
|
||||
///
|
||||
/// # Panics
|
||||
///
|
||||
/// This function panics if there is not enough remaining data in `self`.
|
||||
fn get_u64_ne(&mut self) -> u64 {
|
||||
buf_get_impl!(self, u64::from_ne_bytes);
|
||||
}
|
||||
|
||||
/// Gets a signed 64 bit integer from `self` in big-endian byte order.
|
||||
///
|
||||
/// The current position is advanced by 8.
|
||||
@@ -694,29 +551,6 @@ pub trait Buf {
|
||||
buf_get_impl!(self, i64::from_le_bytes);
|
||||
}
|
||||
|
||||
/// Gets a signed 64 bit integer from `self` in native-endian byte order.
|
||||
///
|
||||
/// The current position is advanced by 8.
|
||||
///
|
||||
/// # Examples
|
||||
///
|
||||
/// ```
|
||||
/// use bytes::Buf;
|
||||
///
|
||||
/// let mut buf: &[u8] = match cfg!(target_endian = "big") {
|
||||
/// true => b"\x01\x02\x03\x04\x05\x06\x07\x08 hello",
|
||||
/// false => b"\x08\x07\x06\x05\x04\x03\x02\x01 hello",
|
||||
/// };
|
||||
/// assert_eq!(0x0102030405060708, buf.get_i64_ne());
|
||||
/// ```
|
||||
///
|
||||
/// # Panics
|
||||
///
|
||||
/// This function panics if there is not enough remaining data in `self`.
|
||||
fn get_i64_ne(&mut self) -> i64 {
|
||||
buf_get_impl!(self, i64::from_ne_bytes);
|
||||
}
|
||||
|
||||
/// Gets an unsigned 128 bit integer from `self` in big-endian byte order.
|
||||
///
|
||||
/// The current position is advanced by 16.
|
||||
@@ -757,29 +591,6 @@ pub trait Buf {
|
||||
buf_get_impl!(self, u128::from_le_bytes);
|
||||
}
|
||||
|
||||
/// Gets an unsigned 128 bit integer from `self` in native-endian byte order.
|
||||
///
|
||||
/// The current position is advanced by 16.
|
||||
///
|
||||
/// # Examples
|
||||
///
|
||||
/// ```
|
||||
/// use bytes::Buf;
|
||||
///
|
||||
/// let mut buf: &[u8] = match cfg!(target_endian = "big") {
|
||||
/// true => b"\x01\x02\x03\x04\x05\x06\x07\x08\x09\x10\x11\x12\x13\x14\x15\x16 hello",
|
||||
/// false => b"\x16\x15\x14\x13\x12\x11\x10\x09\x08\x07\x06\x05\x04\x03\x02\x01 hello",
|
||||
/// };
|
||||
/// assert_eq!(0x01020304050607080910111213141516, buf.get_u128_ne());
|
||||
/// ```
|
||||
///
|
||||
/// # Panics
|
||||
///
|
||||
/// This function panics if there is not enough remaining data in `self`.
|
||||
fn get_u128_ne(&mut self) -> u128 {
|
||||
buf_get_impl!(self, u128::from_ne_bytes);
|
||||
}
|
||||
|
||||
/// Gets a signed 128 bit integer from `self` in big-endian byte order.
|
||||
///
|
||||
/// The current position is advanced by 16.
|
||||
@@ -820,29 +631,6 @@ pub trait Buf {
|
||||
buf_get_impl!(self, i128::from_le_bytes);
|
||||
}
|
||||
|
||||
/// Gets a signed 128 bit integer from `self` in native-endian byte order.
|
||||
///
|
||||
/// The current position is advanced by 16.
|
||||
///
|
||||
/// # Examples
|
||||
///
|
||||
/// ```
|
||||
/// use bytes::Buf;
|
||||
///
|
||||
/// let mut buf: &[u8] = match cfg!(target_endian = "big") {
|
||||
/// true => b"\x01\x02\x03\x04\x05\x06\x07\x08\x09\x10\x11\x12\x13\x14\x15\x16 hello",
|
||||
/// false => b"\x16\x15\x14\x13\x12\x11\x10\x09\x08\x07\x06\x05\x04\x03\x02\x01 hello",
|
||||
/// };
|
||||
/// assert_eq!(0x01020304050607080910111213141516, buf.get_i128_ne());
|
||||
/// ```
|
||||
///
|
||||
/// # Panics
|
||||
///
|
||||
/// This function panics if there is not enough remaining data in `self`.
|
||||
fn get_i128_ne(&mut self) -> i128 {
|
||||
buf_get_impl!(self, i128::from_ne_bytes);
|
||||
}
|
||||
|
||||
/// Gets an unsigned n-byte integer from `self` in big-endian byte order.
|
||||
///
|
||||
/// The current position is advanced by `nbytes`.
|
||||
@@ -883,34 +671,6 @@ pub trait Buf {
|
||||
buf_get_impl!(le => self, u64, nbytes);
|
||||
}
|
||||
|
||||
/// Gets an unsigned n-byte integer from `self` in native-endian byte order.
|
||||
///
|
||||
/// The current position is advanced by `nbytes`.
|
||||
///
|
||||
/// # Examples
|
||||
///
|
||||
/// ```
|
||||
/// use bytes::Buf;
|
||||
///
|
||||
/// let mut buf: &[u8] = match cfg!(target_endian = "big") {
|
||||
/// true => b"\x01\x02\x03 hello",
|
||||
/// false => b"\x03\x02\x01 hello",
|
||||
/// };
|
||||
/// assert_eq!(0x010203, buf.get_uint_ne(3));
|
||||
/// ```
|
||||
///
|
||||
/// # Panics
|
||||
///
|
||||
/// This function panics if there is not enough remaining data in `self`, or
|
||||
/// if `nbytes` is greater than 8.
|
||||
fn get_uint_ne(&mut self, nbytes: usize) -> u64 {
|
||||
if cfg!(target_endian = "big") {
|
||||
self.get_uint(nbytes)
|
||||
} else {
|
||||
self.get_uint_le(nbytes)
|
||||
}
|
||||
}
|
||||
|
||||
/// Gets a signed n-byte integer from `self` in big-endian byte order.
|
||||
///
|
||||
/// The current position is advanced by `nbytes`.
|
||||
@@ -926,10 +686,9 @@ pub trait Buf {
|
||||
///
|
||||
/// # Panics
|
||||
///
|
||||
/// This function panics if there is not enough remaining data in `self`, or
|
||||
/// if `nbytes` is greater than 8.
|
||||
/// This function panics if there is not enough remaining data in `self`.
|
||||
fn get_int(&mut self, nbytes: usize) -> i64 {
|
||||
sign_extend(self.get_uint(nbytes), nbytes)
|
||||
buf_get_impl!(be => self, i64, nbytes);
|
||||
}
|
||||
|
||||
/// Gets a signed n-byte integer from `self` in little-endian byte order.
|
||||
@@ -947,38 +706,9 @@ pub trait Buf {
|
||||
///
|
||||
/// # Panics
|
||||
///
|
||||
/// This function panics if there is not enough remaining data in `self`, or
|
||||
/// if `nbytes` is greater than 8.
|
||||
/// This function panics if there is not enough remaining data in `self`.
|
||||
fn get_int_le(&mut self, nbytes: usize) -> i64 {
|
||||
sign_extend(self.get_uint_le(nbytes), nbytes)
|
||||
}
|
||||
|
||||
/// Gets a signed n-byte integer from `self` in native-endian byte order.
|
||||
///
|
||||
/// The current position is advanced by `nbytes`.
|
||||
///
|
||||
/// # Examples
|
||||
///
|
||||
/// ```
|
||||
/// use bytes::Buf;
|
||||
///
|
||||
/// let mut buf: &[u8] = match cfg!(target_endian = "big") {
|
||||
/// true => b"\x01\x02\x03 hello",
|
||||
/// false => b"\x03\x02\x01 hello",
|
||||
/// };
|
||||
/// assert_eq!(0x010203, buf.get_int_ne(3));
|
||||
/// ```
|
||||
///
|
||||
/// # Panics
|
||||
///
|
||||
/// This function panics if there is not enough remaining data in `self`, or
|
||||
/// if `nbytes` is greater than 8.
|
||||
fn get_int_ne(&mut self, nbytes: usize) -> i64 {
|
||||
if cfg!(target_endian = "big") {
|
||||
self.get_int(nbytes)
|
||||
} else {
|
||||
self.get_int_le(nbytes)
|
||||
}
|
||||
buf_get_impl!(le => self, i64, nbytes);
|
||||
}
|
||||
|
||||
/// Gets an IEEE754 single-precision (4 bytes) floating point number from
|
||||
@@ -999,7 +729,7 @@ pub trait Buf {
|
||||
///
|
||||
/// This function panics if there is not enough remaining data in `self`.
|
||||
fn get_f32(&mut self) -> f32 {
|
||||
f32::from_bits(self.get_u32())
|
||||
f32::from_bits(Self::get_u32(self))
|
||||
}
|
||||
|
||||
/// Gets an IEEE754 single-precision (4 bytes) floating point number from
|
||||
@@ -1020,31 +750,7 @@ pub trait Buf {
|
||||
///
|
||||
/// 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())
|
||||
}
|
||||
|
||||
/// Gets an IEEE754 single-precision (4 bytes) floating point number from
|
||||
/// `self` in native-endian byte order.
|
||||
///
|
||||
/// The current position is advanced by 4.
|
||||
///
|
||||
/// # Examples
|
||||
///
|
||||
/// ```
|
||||
/// use bytes::Buf;
|
||||
///
|
||||
/// let mut buf: &[u8] = match cfg!(target_endian = "big") {
|
||||
/// true => b"\x3F\x99\x99\x9A hello",
|
||||
/// false => b"\x9A\x99\x99\x3F hello",
|
||||
/// };
|
||||
/// assert_eq!(1.2f32, buf.get_f32_ne());
|
||||
/// ```
|
||||
///
|
||||
/// # Panics
|
||||
///
|
||||
/// This function panics if there is not enough remaining data in `self`.
|
||||
fn get_f32_ne(&mut self) -> f32 {
|
||||
f32::from_bits(self.get_u32_ne())
|
||||
f32::from_bits(Self::get_u32_le(self))
|
||||
}
|
||||
|
||||
/// Gets an IEEE754 double-precision (8 bytes) floating point number from
|
||||
@@ -1065,7 +771,7 @@ pub trait Buf {
|
||||
///
|
||||
/// This function panics if there is not enough remaining data in `self`.
|
||||
fn get_f64(&mut self) -> f64 {
|
||||
f64::from_bits(self.get_u64())
|
||||
f64::from_bits(Self::get_u64(self))
|
||||
}
|
||||
|
||||
/// Gets an IEEE754 double-precision (8 bytes) floating point number from
|
||||
@@ -1086,31 +792,7 @@ pub trait Buf {
|
||||
///
|
||||
/// 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())
|
||||
}
|
||||
|
||||
/// Gets an IEEE754 double-precision (8 bytes) floating point number from
|
||||
/// `self` in native-endian byte order.
|
||||
///
|
||||
/// The current position is advanced by 8.
|
||||
///
|
||||
/// # Examples
|
||||
///
|
||||
/// ```
|
||||
/// use bytes::Buf;
|
||||
///
|
||||
/// let mut buf: &[u8] = match cfg!(target_endian = "big") {
|
||||
/// true => b"\x3F\xF3\x33\x33\x33\x33\x33\x33 hello",
|
||||
/// false => b"\x33\x33\x33\x33\x33\x33\xF3\x3F hello",
|
||||
/// };
|
||||
/// assert_eq!(1.2f64, buf.get_f64_ne());
|
||||
/// ```
|
||||
///
|
||||
/// # Panics
|
||||
///
|
||||
/// This function panics if there is not enough remaining data in `self`.
|
||||
fn get_f64_ne(&mut self) -> f64 {
|
||||
f64::from_bits(self.get_u64_ne())
|
||||
f64::from_bits(Self::get_u64_le(self))
|
||||
}
|
||||
|
||||
/// Consumes `len` bytes inside self and returns new instance of `Bytes`
|
||||
@@ -1128,16 +810,10 @@ pub trait Buf {
|
||||
/// let bytes = (&b"hello world"[..]).copy_to_bytes(5);
|
||||
/// assert_eq!(&bytes[..], &b"hello"[..]);
|
||||
/// ```
|
||||
///
|
||||
/// # Panics
|
||||
///
|
||||
/// This function panics if `len > self.remaining()`.
|
||||
fn copy_to_bytes(&mut self, len: usize) -> crate::Bytes {
|
||||
use super::BufMut;
|
||||
|
||||
if self.remaining() < len {
|
||||
panic_advance(len, self.remaining());
|
||||
}
|
||||
assert!(len <= self.remaining(), "`len` greater than remaining");
|
||||
|
||||
let mut ret = crate::BytesMut::with_capacity(len);
|
||||
ret.put(self.take(len));
|
||||
@@ -1185,7 +861,7 @@ pub trait Buf {
|
||||
/// let mut chain = b"hello "[..].chain(&b"world"[..]);
|
||||
///
|
||||
/// let full = chain.copy_to_bytes(11);
|
||||
/// assert_eq!(full.chunk(), b"hello world");
|
||||
/// assert_eq!(full.bytes(), b"hello world");
|
||||
/// ```
|
||||
fn chain<U: Buf>(self, next: U) -> Chain<Self, U>
|
||||
where
|
||||
@@ -1218,7 +894,6 @@ pub trait Buf {
|
||||
/// assert_eq!(&dst[..11], &b"hello world"[..]);
|
||||
/// ```
|
||||
#[cfg(feature = "std")]
|
||||
#[cfg_attr(docsrs, doc(cfg(feature = "std")))]
|
||||
fn reader(self) -> Reader<Self>
|
||||
where
|
||||
Self: Sized,
|
||||
@@ -1229,168 +904,103 @@ pub trait Buf {
|
||||
|
||||
macro_rules! deref_forward_buf {
|
||||
() => {
|
||||
#[inline]
|
||||
fn remaining(&self) -> usize {
|
||||
(**self).remaining()
|
||||
}
|
||||
|
||||
#[inline]
|
||||
fn chunk(&self) -> &[u8] {
|
||||
(**self).chunk()
|
||||
fn bytes(&self) -> &[u8] {
|
||||
(**self).bytes()
|
||||
}
|
||||
|
||||
#[cfg(feature = "std")]
|
||||
#[inline]
|
||||
fn chunks_vectored<'b>(&'b self, dst: &mut [IoSlice<'b>]) -> usize {
|
||||
(**self).chunks_vectored(dst)
|
||||
fn bytes_vectored<'b>(&'b self, dst: &mut [IoSlice<'b>]) -> usize {
|
||||
(**self).bytes_vectored(dst)
|
||||
}
|
||||
|
||||
#[inline]
|
||||
fn advance(&mut self, cnt: usize) {
|
||||
(**self).advance(cnt)
|
||||
}
|
||||
|
||||
#[inline]
|
||||
fn has_remaining(&self) -> bool {
|
||||
(**self).has_remaining()
|
||||
}
|
||||
|
||||
#[inline]
|
||||
fn copy_to_slice(&mut self, dst: &mut [u8]) {
|
||||
(**self).copy_to_slice(dst)
|
||||
}
|
||||
|
||||
#[inline]
|
||||
fn get_u8(&mut self) -> u8 {
|
||||
(**self).get_u8()
|
||||
}
|
||||
|
||||
#[inline]
|
||||
fn get_i8(&mut self) -> i8 {
|
||||
(**self).get_i8()
|
||||
}
|
||||
|
||||
#[inline]
|
||||
fn get_u16(&mut self) -> u16 {
|
||||
(**self).get_u16()
|
||||
}
|
||||
|
||||
#[inline]
|
||||
fn get_u16_le(&mut self) -> u16 {
|
||||
(**self).get_u16_le()
|
||||
}
|
||||
|
||||
#[inline]
|
||||
fn get_u16_ne(&mut self) -> u16 {
|
||||
(**self).get_u16_ne()
|
||||
}
|
||||
|
||||
#[inline]
|
||||
fn get_i16(&mut self) -> i16 {
|
||||
(**self).get_i16()
|
||||
}
|
||||
|
||||
#[inline]
|
||||
fn get_i16_le(&mut self) -> i16 {
|
||||
(**self).get_i16_le()
|
||||
}
|
||||
|
||||
#[inline]
|
||||
fn get_i16_ne(&mut self) -> i16 {
|
||||
(**self).get_i16_ne()
|
||||
}
|
||||
|
||||
#[inline]
|
||||
fn get_u32(&mut self) -> u32 {
|
||||
(**self).get_u32()
|
||||
}
|
||||
|
||||
#[inline]
|
||||
fn get_u32_le(&mut self) -> u32 {
|
||||
(**self).get_u32_le()
|
||||
}
|
||||
|
||||
#[inline]
|
||||
fn get_u32_ne(&mut self) -> u32 {
|
||||
(**self).get_u32_ne()
|
||||
}
|
||||
|
||||
#[inline]
|
||||
fn get_i32(&mut self) -> i32 {
|
||||
(**self).get_i32()
|
||||
}
|
||||
|
||||
#[inline]
|
||||
fn get_i32_le(&mut self) -> i32 {
|
||||
(**self).get_i32_le()
|
||||
}
|
||||
|
||||
#[inline]
|
||||
fn get_i32_ne(&mut self) -> i32 {
|
||||
(**self).get_i32_ne()
|
||||
}
|
||||
|
||||
#[inline]
|
||||
fn get_u64(&mut self) -> u64 {
|
||||
(**self).get_u64()
|
||||
}
|
||||
|
||||
#[inline]
|
||||
fn get_u64_le(&mut self) -> u64 {
|
||||
(**self).get_u64_le()
|
||||
}
|
||||
|
||||
#[inline]
|
||||
fn get_u64_ne(&mut self) -> u64 {
|
||||
(**self).get_u64_ne()
|
||||
}
|
||||
|
||||
#[inline]
|
||||
fn get_i64(&mut self) -> i64 {
|
||||
(**self).get_i64()
|
||||
}
|
||||
|
||||
#[inline]
|
||||
fn get_i64_le(&mut self) -> i64 {
|
||||
(**self).get_i64_le()
|
||||
}
|
||||
|
||||
#[inline]
|
||||
fn get_i64_ne(&mut self) -> i64 {
|
||||
(**self).get_i64_ne()
|
||||
}
|
||||
|
||||
#[inline]
|
||||
fn get_uint(&mut self, nbytes: usize) -> u64 {
|
||||
(**self).get_uint(nbytes)
|
||||
}
|
||||
|
||||
#[inline]
|
||||
fn get_uint_le(&mut self, nbytes: usize) -> u64 {
|
||||
(**self).get_uint_le(nbytes)
|
||||
}
|
||||
|
||||
#[inline]
|
||||
fn get_uint_ne(&mut self, nbytes: usize) -> u64 {
|
||||
(**self).get_uint_ne(nbytes)
|
||||
}
|
||||
|
||||
#[inline]
|
||||
fn get_int(&mut self, nbytes: usize) -> i64 {
|
||||
(**self).get_int(nbytes)
|
||||
}
|
||||
|
||||
#[inline]
|
||||
fn get_int_le(&mut self, nbytes: usize) -> i64 {
|
||||
(**self).get_int_le(nbytes)
|
||||
}
|
||||
|
||||
#[inline]
|
||||
fn get_int_ne(&mut self, nbytes: usize) -> i64 {
|
||||
(**self).get_int_ne(nbytes)
|
||||
}
|
||||
|
||||
#[inline]
|
||||
fn copy_to_bytes(&mut self, len: usize) -> crate::Bytes {
|
||||
(**self).copy_to_bytes(len)
|
||||
}
|
||||
@@ -1412,58 +1022,76 @@ impl Buf for &[u8] {
|
||||
}
|
||||
|
||||
#[inline]
|
||||
fn chunk(&self) -> &[u8] {
|
||||
fn bytes(&self) -> &[u8] {
|
||||
self
|
||||
}
|
||||
|
||||
#[inline]
|
||||
fn advance(&mut self, cnt: usize) {
|
||||
if self.len() < cnt {
|
||||
panic_advance(cnt, self.len());
|
||||
}
|
||||
|
||||
*self = &self[cnt..];
|
||||
}
|
||||
}
|
||||
|
||||
#[inline]
|
||||
fn copy_to_slice(&mut self, dst: &mut [u8]) {
|
||||
if self.len() < dst.len() {
|
||||
panic_advance(dst.len(), self.len());
|
||||
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;
|
||||
}
|
||||
|
||||
dst.copy_from_slice(&self[..dst.len()]);
|
||||
self.advance(dst.len());
|
||||
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> {
|
||||
#[inline]
|
||||
fn remaining(&self) -> usize {
|
||||
saturating_sub_usize_u64(self.get_ref().as_ref().len(), self.position())
|
||||
}
|
||||
|
||||
#[inline]
|
||||
fn chunk(&self) -> &[u8] {
|
||||
let slice = self.get_ref().as_ref();
|
||||
let pos = min_u64_usize(self.position(), slice.len());
|
||||
&slice[pos..]
|
||||
}
|
||||
|
||||
#[inline]
|
||||
fn advance(&mut self, cnt: usize) {
|
||||
let len = self.get_ref().as_ref().len();
|
||||
let pos = self.position();
|
||||
|
||||
// We intentionally allow `cnt == 0` here even if `pos > len`.
|
||||
let max_cnt = saturating_sub_usize_u64(len, pos);
|
||||
if cnt > max_cnt {
|
||||
panic_advance(cnt, max_cnt);
|
||||
if pos >= len as u64 {
|
||||
return 0;
|
||||
}
|
||||
|
||||
// This will not overflow because either `cnt == 0` or the sum is not
|
||||
// greater than `len`.
|
||||
self.set_position(pos + cnt as u64);
|
||||
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);
|
||||
}
|
||||
}
|
||||
|
||||
|
||||
+91
-653
File diff suppressed because it is too large
Load Diff
+15
-33
@@ -1,5 +1,5 @@
|
||||
use crate::buf::{IntoIter, UninitSlice};
|
||||
use crate::{Buf, BufMut, Bytes};
|
||||
use crate::{Buf, BufMut};
|
||||
|
||||
#[cfg(feature = "std")]
|
||||
use std::io::IoSlice;
|
||||
@@ -25,7 +25,9 @@ use std::io::IoSlice;
|
||||
/// assert_eq!(full[..], b"hello world"[..]);
|
||||
/// ```
|
||||
///
|
||||
/// [`Buf::chain`]: Buf::chain
|
||||
/// [`Buf::chain`]: trait.Buf.html#method.chain
|
||||
/// [`Buf`]: trait.Buf.html
|
||||
/// [`BufMut`]: trait.BufMut.html
|
||||
#[derive(Debug)]
|
||||
pub struct Chain<T, U> {
|
||||
a: T,
|
||||
@@ -133,14 +135,14 @@ where
|
||||
U: Buf,
|
||||
{
|
||||
fn remaining(&self) -> usize {
|
||||
self.a.remaining().saturating_add(self.b.remaining())
|
||||
self.a.remaining() + self.b.remaining()
|
||||
}
|
||||
|
||||
fn chunk(&self) -> &[u8] {
|
||||
fn bytes(&self) -> &[u8] {
|
||||
if self.a.has_remaining() {
|
||||
self.a.chunk()
|
||||
self.a.bytes()
|
||||
} else {
|
||||
self.b.chunk()
|
||||
self.b.bytes()
|
||||
}
|
||||
}
|
||||
|
||||
@@ -163,29 +165,11 @@ where
|
||||
}
|
||||
|
||||
#[cfg(feature = "std")]
|
||||
fn chunks_vectored<'a>(&'a self, dst: &mut [IoSlice<'a>]) -> usize {
|
||||
let mut n = self.a.chunks_vectored(dst);
|
||||
n += self.b.chunks_vectored(&mut dst[n..]);
|
||||
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
|
||||
}
|
||||
|
||||
fn copy_to_bytes(&mut self, len: usize) -> Bytes {
|
||||
let a_rem = self.a.remaining();
|
||||
if a_rem >= len {
|
||||
self.a.copy_to_bytes(len)
|
||||
} else if a_rem == 0 {
|
||||
self.b.copy_to_bytes(len)
|
||||
} else {
|
||||
assert!(
|
||||
len - a_rem <= self.b.remaining(),
|
||||
"`len` greater than remaining"
|
||||
);
|
||||
let mut ret = crate::BytesMut::with_capacity(len);
|
||||
ret.put(&mut self.a);
|
||||
ret.put((&mut self.b).take(len - a_rem));
|
||||
ret.freeze()
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
unsafe impl<T, U> BufMut for Chain<T, U>
|
||||
@@ -194,16 +178,14 @@ where
|
||||
U: BufMut,
|
||||
{
|
||||
fn remaining_mut(&self) -> usize {
|
||||
self.a
|
||||
.remaining_mut()
|
||||
.saturating_add(self.b.remaining_mut())
|
||||
self.a.remaining_mut() + self.b.remaining_mut()
|
||||
}
|
||||
|
||||
fn chunk_mut(&mut self) -> &mut UninitSlice {
|
||||
fn bytes_mut(&mut self) -> &mut UninitSlice {
|
||||
if self.a.has_remaining_mut() {
|
||||
self.a.chunk_mut()
|
||||
self.a.bytes_mut()
|
||||
} else {
|
||||
self.b.chunk_mut()
|
||||
self.b.bytes_mut()
|
||||
}
|
||||
}
|
||||
|
||||
|
||||
+7
-2
@@ -2,6 +2,8 @@ use crate::Buf;
|
||||
|
||||
/// Iterator over the bytes contained by the buffer.
|
||||
///
|
||||
/// This struct is created by the [`iter`] method on [`Buf`].
|
||||
///
|
||||
/// # Examples
|
||||
///
|
||||
/// Basic usage:
|
||||
@@ -17,6 +19,9 @@ use crate::Buf;
|
||||
/// 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,
|
||||
@@ -38,7 +43,7 @@ impl<T> IntoIter<T> {
|
||||
/// assert_eq!(iter.next(), Some(b'c'));
|
||||
/// assert_eq!(iter.next(), None);
|
||||
/// ```
|
||||
pub fn new(inner: T) -> IntoIter<T> {
|
||||
pub(crate) fn new(inner: T) -> IntoIter<T> {
|
||||
IntoIter { inner }
|
||||
}
|
||||
|
||||
@@ -112,7 +117,7 @@ impl<T: Buf> Iterator for IntoIter<T> {
|
||||
return None;
|
||||
}
|
||||
|
||||
let b = self.inner.chunk()[0];
|
||||
let b = self.inner.bytes()[0];
|
||||
self.inner.advance(1);
|
||||
|
||||
Some(b)
|
||||
|
||||
+2
-2
@@ -61,8 +61,8 @@ unsafe impl<T: BufMut> BufMut for Limit<T> {
|
||||
cmp::min(self.inner.remaining_mut(), self.limit)
|
||||
}
|
||||
|
||||
fn chunk_mut(&mut self) -> &mut UninitSlice {
|
||||
let bytes = self.inner.chunk_mut();
|
||||
fn bytes_mut(&mut self) -> &mut UninitSlice {
|
||||
let bytes = self.inner.bytes_mut();
|
||||
let end = cmp::min(bytes.len(), self.limit);
|
||||
&mut bytes[..end]
|
||||
}
|
||||
|
||||
@@ -13,6 +13,8 @@
|
||||
//! 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;
|
||||
|
||||
+2
-2
@@ -5,7 +5,7 @@ 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()`](Buf::reader) for more
|
||||
/// documentation of [`reader()`](trait.Buf.html#method.reader) for more
|
||||
/// details.
|
||||
#[derive(Debug)]
|
||||
pub struct Reader<B> {
|
||||
@@ -73,7 +73,7 @@ impl<B: Buf + Sized> io::Read for Reader<B> {
|
||||
|
||||
impl<B: Buf + Sized> io::BufRead for Reader<B> {
|
||||
fn fill_buf(&mut self) -> io::Result<&[u8]> {
|
||||
Ok(self.buf.chunk())
|
||||
Ok(self.buf.bytes())
|
||||
}
|
||||
fn consume(&mut self, amt: usize) {
|
||||
self.buf.advance(amt)
|
||||
|
||||
+4
-12
@@ -1,11 +1,11 @@
|
||||
use crate::{Buf, Bytes};
|
||||
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()`](Buf::take) for more details.
|
||||
/// documentation of [`take()`](trait.BufExt.html#method.take) for more details.
|
||||
#[derive(Debug)]
|
||||
pub struct Take<T> {
|
||||
inner: T,
|
||||
@@ -134,8 +134,8 @@ impl<T: Buf> Buf for Take<T> {
|
||||
cmp::min(self.inner.remaining(), self.limit)
|
||||
}
|
||||
|
||||
fn chunk(&self) -> &[u8] {
|
||||
let bytes = self.inner.chunk();
|
||||
fn bytes(&self) -> &[u8] {
|
||||
let bytes = self.inner.bytes();
|
||||
&bytes[..cmp::min(bytes.len(), self.limit)]
|
||||
}
|
||||
|
||||
@@ -144,12 +144,4 @@ impl<T: Buf> Buf for Take<T> {
|
||||
self.inner.advance(cnt);
|
||||
self.limit -= cnt;
|
||||
}
|
||||
|
||||
fn copy_to_bytes(&mut self, len: usize) -> Bytes {
|
||||
assert!(len <= self.remaining(), "`len` greater than remaining");
|
||||
|
||||
let r = self.inner.copy_to_bytes(len);
|
||||
self.limit -= len;
|
||||
r
|
||||
}
|
||||
}
|
||||
|
||||
+9
-90
@@ -6,7 +6,7 @@ use core::ops::{
|
||||
|
||||
/// Uninitialized byte slice.
|
||||
///
|
||||
/// Returned by `BufMut::chunk_mut()`, the referenced byte slice may be
|
||||
/// Returned by `BufMut::bytes_mut()`, the referenced byte slice may be
|
||||
/// uninitialized. The wrapper provides safe access without introducing
|
||||
/// undefined behavior.
|
||||
///
|
||||
@@ -22,44 +22,6 @@ use core::ops::{
|
||||
pub struct UninitSlice([MaybeUninit<u8>]);
|
||||
|
||||
impl UninitSlice {
|
||||
/// Creates a `&mut UninitSlice` wrapping a slice of initialised memory.
|
||||
///
|
||||
/// # Examples
|
||||
///
|
||||
/// ```
|
||||
/// use bytes::buf::UninitSlice;
|
||||
///
|
||||
/// let mut buffer = [0u8; 64];
|
||||
/// let slice = UninitSlice::new(&mut buffer[..]);
|
||||
/// ```
|
||||
#[inline]
|
||||
pub fn new(slice: &mut [u8]) -> &mut UninitSlice {
|
||||
unsafe { &mut *(slice as *mut [u8] as *mut [MaybeUninit<u8>] as *mut UninitSlice) }
|
||||
}
|
||||
|
||||
/// Creates a `&mut UninitSlice` wrapping a slice of uninitialised memory.
|
||||
///
|
||||
/// # Examples
|
||||
///
|
||||
/// ```
|
||||
/// use bytes::buf::UninitSlice;
|
||||
/// use core::mem::MaybeUninit;
|
||||
///
|
||||
/// let mut buffer = [MaybeUninit::uninit(); 64];
|
||||
/// let slice = UninitSlice::uninit(&mut buffer[..]);
|
||||
///
|
||||
/// let mut vec = Vec::with_capacity(1024);
|
||||
/// let spare: &mut UninitSlice = vec.spare_capacity_mut().into();
|
||||
/// ```
|
||||
#[inline]
|
||||
pub fn uninit(slice: &mut [MaybeUninit<u8>]) -> &mut UninitSlice {
|
||||
unsafe { &mut *(slice as *mut [MaybeUninit<u8>] as *mut UninitSlice) }
|
||||
}
|
||||
|
||||
fn uninit_ref(slice: &[MaybeUninit<u8>]) -> &UninitSlice {
|
||||
unsafe { &*(slice as *const [MaybeUninit<u8>] as *const UninitSlice) }
|
||||
}
|
||||
|
||||
/// Create a `&mut UninitSlice` from a pointer and a length.
|
||||
///
|
||||
/// # Safety
|
||||
@@ -78,11 +40,10 @@ impl UninitSlice {
|
||||
///
|
||||
/// let slice = unsafe { UninitSlice::from_raw_parts_mut(ptr, len) };
|
||||
/// ```
|
||||
#[inline]
|
||||
pub unsafe fn from_raw_parts_mut<'a>(ptr: *mut u8, len: usize) -> &'a mut UninitSlice {
|
||||
let maybe_init: &mut [MaybeUninit<u8>] =
|
||||
core::slice::from_raw_parts_mut(ptr as *mut _, len);
|
||||
Self::uninit(maybe_init)
|
||||
&mut *(maybe_init as *mut [MaybeUninit<u8>] as *mut UninitSlice)
|
||||
}
|
||||
|
||||
/// Write a single byte at the specified offset.
|
||||
@@ -103,14 +64,13 @@ impl UninitSlice {
|
||||
///
|
||||
/// assert_eq!(b"boo", &data[..]);
|
||||
/// ```
|
||||
#[inline]
|
||||
pub fn write_byte(&mut self, index: usize, byte: u8) {
|
||||
assert!(index < self.len());
|
||||
|
||||
unsafe { self[index..].as_mut_ptr().write(byte) }
|
||||
}
|
||||
|
||||
/// Copies bytes from `src` into `self`.
|
||||
/// Copies bytes from `src` into `self`.
|
||||
///
|
||||
/// The length of `src` must be the same as `self`.
|
||||
///
|
||||
@@ -130,7 +90,6 @@ impl UninitSlice {
|
||||
///
|
||||
/// assert_eq!(b"bar", &data[..]);
|
||||
/// ```
|
||||
#[inline]
|
||||
pub fn copy_from_slice(&mut self, src: &[u8]) {
|
||||
use core::ptr;
|
||||
|
||||
@@ -155,39 +114,12 @@ impl UninitSlice {
|
||||
///
|
||||
/// let mut data = [0, 1, 2];
|
||||
/// let mut slice = &mut data[..];
|
||||
/// let ptr = BufMut::chunk_mut(&mut slice).as_mut_ptr();
|
||||
/// let ptr = BufMut::bytes_mut(&mut slice).as_mut_ptr();
|
||||
/// ```
|
||||
#[inline]
|
||||
pub fn as_mut_ptr(&mut self) -> *mut u8 {
|
||||
self.0.as_mut_ptr() as *mut _
|
||||
}
|
||||
|
||||
/// Return a `&mut [MaybeUninit<u8>]` to this slice's buffer.
|
||||
///
|
||||
/// # Safety
|
||||
///
|
||||
/// The caller **must not** read from the referenced memory and **must not** write
|
||||
/// **uninitialized** bytes to the slice either. This is because `BufMut` implementation
|
||||
/// that created the `UninitSlice` knows which parts are initialized. Writing uninitialized
|
||||
/// bytes to the slice may cause the `BufMut` to read those bytes and trigger undefined
|
||||
/// behavior.
|
||||
///
|
||||
/// # Examples
|
||||
///
|
||||
/// ```
|
||||
/// use bytes::BufMut;
|
||||
///
|
||||
/// let mut data = [0, 1, 2];
|
||||
/// let mut slice = &mut data[..];
|
||||
/// unsafe {
|
||||
/// let uninit_slice = BufMut::chunk_mut(&mut slice).as_uninit_slice_mut();
|
||||
/// };
|
||||
/// ```
|
||||
#[inline]
|
||||
pub unsafe fn as_uninit_slice_mut(&mut self) -> &mut [MaybeUninit<u8>] {
|
||||
&mut self.0
|
||||
}
|
||||
|
||||
/// Returns the number of bytes in the slice.
|
||||
///
|
||||
/// # Examples
|
||||
@@ -197,11 +129,10 @@ impl UninitSlice {
|
||||
///
|
||||
/// let mut data = [0, 1, 2];
|
||||
/// let mut slice = &mut data[..];
|
||||
/// let len = BufMut::chunk_mut(&mut slice).len();
|
||||
/// let len = BufMut::bytes_mut(&mut slice).len();
|
||||
///
|
||||
/// assert_eq!(len, 3);
|
||||
/// ```
|
||||
#[inline]
|
||||
pub fn len(&self) -> usize {
|
||||
self.0.len()
|
||||
}
|
||||
@@ -213,34 +144,22 @@ impl fmt::Debug for UninitSlice {
|
||||
}
|
||||
}
|
||||
|
||||
impl<'a> From<&'a mut [u8]> for &'a mut UninitSlice {
|
||||
fn from(slice: &'a mut [u8]) -> Self {
|
||||
UninitSlice::new(slice)
|
||||
}
|
||||
}
|
||||
|
||||
impl<'a> From<&'a mut [MaybeUninit<u8>]> for &'a mut UninitSlice {
|
||||
fn from(slice: &'a mut [MaybeUninit<u8>]) -> Self {
|
||||
UninitSlice::uninit(slice)
|
||||
}
|
||||
}
|
||||
|
||||
macro_rules! impl_index {
|
||||
($($t:ty),*) => {
|
||||
$(
|
||||
impl Index<$t> for UninitSlice {
|
||||
type Output = UninitSlice;
|
||||
|
||||
#[inline]
|
||||
fn index(&self, index: $t) -> &UninitSlice {
|
||||
UninitSlice::uninit_ref(&self.0[index])
|
||||
let maybe_uninit: &[MaybeUninit<u8>] = &self.0[index];
|
||||
unsafe { &*(maybe_uninit as *const [MaybeUninit<u8>] as *const UninitSlice) }
|
||||
}
|
||||
}
|
||||
|
||||
impl IndexMut<$t> for UninitSlice {
|
||||
#[inline]
|
||||
fn index_mut(&mut self, index: $t) -> &mut UninitSlice {
|
||||
UninitSlice::uninit(&mut self.0[index])
|
||||
let maybe_uninit: &mut [MaybeUninit<u8>] = &mut self.0[index];
|
||||
unsafe { &mut *(maybe_uninit as *mut [MaybeUninit<u8>] as *mut UninitSlice) }
|
||||
}
|
||||
}
|
||||
)*
|
||||
|
||||
@@ -7,7 +7,7 @@ impl Buf for VecDeque<u8> {
|
||||
self.len()
|
||||
}
|
||||
|
||||
fn chunk(&self) -> &[u8] {
|
||||
fn bytes(&self) -> &[u8] {
|
||||
let (s1, s2) = self.as_slices();
|
||||
if s1.is_empty() {
|
||||
s2
|
||||
|
||||
+1
-1
@@ -5,7 +5,7 @@ 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()`](BufMut::writer) for more
|
||||
/// documentation of [`writer()`](trait.BufMut.html#method.writer) for more
|
||||
/// details.
|
||||
#[derive(Debug)]
|
||||
pub struct Writer<B> {
|
||||
|
||||
+116
-484
@@ -1,21 +1,14 @@
|
||||
use core::iter::FromIterator;
|
||||
use core::mem::{self, ManuallyDrop};
|
||||
use core::ops::{Deref, RangeBounds};
|
||||
use core::{cmp, fmt, hash, ptr, slice, usize};
|
||||
use core::{cmp, fmt, hash, mem, ptr, slice, usize};
|
||||
|
||||
use alloc::{
|
||||
alloc::{dealloc, Layout},
|
||||
borrow::Borrow,
|
||||
boxed::Box,
|
||||
string::String,
|
||||
vec::Vec,
|
||||
};
|
||||
use alloc::{borrow::Borrow, boxed::Box, string::String, vec::Vec};
|
||||
|
||||
use crate::buf::IntoIter;
|
||||
#[allow(unused)]
|
||||
use crate::loom::sync::atomic::AtomicMut;
|
||||
use crate::loom::sync::atomic::{AtomicPtr, AtomicUsize, Ordering};
|
||||
use crate::{offset_from, Buf, BytesMut};
|
||||
use crate::loom::sync::atomic::{self, AtomicPtr, AtomicUsize, Ordering};
|
||||
use crate::Buf;
|
||||
|
||||
/// A cheaply cloneable and sliceable chunk of contiguous memory.
|
||||
///
|
||||
@@ -33,7 +26,7 @@ use crate::{offset_from, Buf, BytesMut};
|
||||
/// All `Bytes` implementations must fulfill the following requirements:
|
||||
/// - They are cheaply cloneable and thereby shareable between an unlimited amount
|
||||
/// of components, for example by modifying a reference count.
|
||||
/// - Instances can be sliced to refer to a subset of the original buffer.
|
||||
/// - Instances can be sliced to refer to a subset of the the original buffer.
|
||||
///
|
||||
/// ```
|
||||
/// use bytes::Bytes;
|
||||
@@ -62,17 +55,17 @@ use crate::{offset_from, Buf, BytesMut};
|
||||
/// # Sharing
|
||||
///
|
||||
/// `Bytes` contains a vtable, which allows implementations of `Bytes` to define
|
||||
/// how sharing/cloning is implemented in detail.
|
||||
/// how sharing/cloneing is implemented in detail.
|
||||
/// When `Bytes::clone()` is called, `Bytes` will call the vtable function for
|
||||
/// cloning the backing storage in order to share it behind multiple `Bytes`
|
||||
/// instances.
|
||||
/// cloning the backing storage in order to share it behind between multiple
|
||||
/// `Bytes` instances.
|
||||
///
|
||||
/// For `Bytes` implementations which refer to constant memory (e.g. created
|
||||
/// via `Bytes::from_static()`) the cloning implementation will be a no-op.
|
||||
///
|
||||
/// For `Bytes` implementations which point to a reference counted shared storage
|
||||
/// (e.g. an `Arc<[u8]>`), sharing will be implemented by increasing the
|
||||
/// reference count.
|
||||
/// the reference count.
|
||||
///
|
||||
/// Due to this mechanism, multiple `Bytes` instances may point to the same
|
||||
/// shared memory region.
|
||||
@@ -85,18 +78,18 @@ use crate::{offset_from, Buf, BytesMut};
|
||||
///
|
||||
/// ```text
|
||||
///
|
||||
/// Arc ptrs ┌─────────┐
|
||||
/// ________________________ / │ Bytes 2 │
|
||||
/// / └─────────┘
|
||||
/// / ┌───────────┐ | |
|
||||
/// |_________/ │ Bytes 1 │ | |
|
||||
/// | └───────────┘ | |
|
||||
/// Arc ptrs +---------+
|
||||
/// ________________________ / | Bytes 2 |
|
||||
/// / +---------+
|
||||
/// / +-----------+ | |
|
||||
/// |_________/ | Bytes 1 | | |
|
||||
/// | +-----------+ | |
|
||||
/// | | | ___/ data | tail
|
||||
/// | data | tail |/ |
|
||||
/// v v v v
|
||||
/// ┌─────┬─────┬───────────┬───────────────┬─────┐
|
||||
/// │ Arc │ │ │ │ │
|
||||
/// └─────┴─────┴───────────┴───────────────┴─────┘
|
||||
/// +-----+---------------------------------+-----+
|
||||
/// | Arc | | | | |
|
||||
/// +-----+---------------------------------+-----+
|
||||
/// ```
|
||||
pub struct Bytes {
|
||||
ptr: *const u8,
|
||||
@@ -110,13 +103,6 @@ pub(crate) struct Vtable {
|
||||
/// fn(data, ptr, len)
|
||||
pub clone: unsafe fn(&AtomicPtr<()>, *const u8, usize) -> Bytes,
|
||||
/// fn(data, ptr, len)
|
||||
///
|
||||
/// takes `Bytes` to value
|
||||
pub to_vec: unsafe fn(&AtomicPtr<()>, *const u8, usize) -> Vec<u8>,
|
||||
pub to_mut: unsafe fn(&AtomicPtr<()>, *const u8, usize) -> BytesMut,
|
||||
/// fn(data)
|
||||
pub is_unique: unsafe fn(&AtomicPtr<()>) -> bool,
|
||||
/// fn(data, ptr, len)
|
||||
pub drop: unsafe fn(&mut AtomicPtr<()>, *const u8, usize),
|
||||
}
|
||||
|
||||
@@ -135,16 +121,15 @@ impl Bytes {
|
||||
/// ```
|
||||
#[inline]
|
||||
#[cfg(not(all(loom, test)))]
|
||||
pub const fn new() -> Self {
|
||||
pub const fn new() -> Bytes {
|
||||
// Make it a named const to work around
|
||||
// "unsizing casts are not allowed in const fn"
|
||||
const EMPTY: &[u8] = &[];
|
||||
Bytes::from_static(EMPTY)
|
||||
}
|
||||
|
||||
/// Creates a new empty `Bytes`.
|
||||
#[cfg(all(loom, test))]
|
||||
pub fn new() -> Self {
|
||||
pub fn new() -> Bytes {
|
||||
const EMPTY: &[u8] = &[];
|
||||
Bytes::from_static(EMPTY)
|
||||
}
|
||||
@@ -164,7 +149,7 @@ impl Bytes {
|
||||
/// ```
|
||||
#[inline]
|
||||
#[cfg(not(all(loom, test)))]
|
||||
pub const fn from_static(bytes: &'static [u8]) -> Self {
|
||||
pub const fn from_static(bytes: &'static [u8]) -> Bytes {
|
||||
Bytes {
|
||||
ptr: bytes.as_ptr(),
|
||||
len: bytes.len(),
|
||||
@@ -173,9 +158,8 @@ impl Bytes {
|
||||
}
|
||||
}
|
||||
|
||||
/// Creates a new `Bytes` from a static slice.
|
||||
#[cfg(all(loom, test))]
|
||||
pub fn from_static(bytes: &'static [u8]) -> Self {
|
||||
pub fn from_static(bytes: &'static [u8]) -> Bytes {
|
||||
Bytes {
|
||||
ptr: bytes.as_ptr(),
|
||||
len: bytes.len(),
|
||||
@@ -184,22 +168,6 @@ impl Bytes {
|
||||
}
|
||||
}
|
||||
|
||||
/// Creates a new `Bytes` with length zero and the given pointer as the address.
|
||||
fn new_empty_with_ptr(ptr: *const u8) -> Self {
|
||||
debug_assert!(!ptr.is_null());
|
||||
|
||||
// Detach this pointer's provenance from whichever allocation it came from, and reattach it
|
||||
// to the provenance of the fake ZST [u8;0] at the same address.
|
||||
let ptr = without_provenance(ptr as usize);
|
||||
|
||||
Bytes {
|
||||
ptr,
|
||||
len: 0,
|
||||
data: AtomicPtr::new(ptr::null_mut()),
|
||||
vtable: &STATIC_VTABLE,
|
||||
}
|
||||
}
|
||||
|
||||
/// Returns the number of bytes contained in this `Bytes`.
|
||||
///
|
||||
/// # Examples
|
||||
@@ -211,7 +179,7 @@ impl Bytes {
|
||||
/// assert_eq!(b.len(), 5);
|
||||
/// ```
|
||||
#[inline]
|
||||
pub const fn len(&self) -> usize {
|
||||
pub fn len(&self) -> usize {
|
||||
self.len
|
||||
}
|
||||
|
||||
@@ -226,32 +194,10 @@ impl Bytes {
|
||||
/// assert!(b.is_empty());
|
||||
/// ```
|
||||
#[inline]
|
||||
pub const fn is_empty(&self) -> bool {
|
||||
pub fn is_empty(&self) -> bool {
|
||||
self.len == 0
|
||||
}
|
||||
|
||||
/// Returns true if this is the only reference to the data.
|
||||
///
|
||||
/// Always returns false if the data is backed by a static slice.
|
||||
///
|
||||
/// The result of this method may be invalidated immediately if another
|
||||
/// thread clones this value while this is being called. Ensure you have
|
||||
/// unique access to this value (`&mut Bytes`) first if you need to be
|
||||
/// certain the result is valid (i.e. for safety reasons)
|
||||
/// # Examples
|
||||
///
|
||||
/// ```
|
||||
/// use bytes::Bytes;
|
||||
///
|
||||
/// let a = Bytes::from(vec![1, 2, 3]);
|
||||
/// assert!(a.is_unique());
|
||||
/// let b = a.clone();
|
||||
/// assert!(!a.is_unique());
|
||||
/// ```
|
||||
pub fn is_unique(&self) -> bool {
|
||||
unsafe { (self.vtable.is_unique)(&self.data) }
|
||||
}
|
||||
|
||||
/// Creates `Bytes` instance from slice, by copying it.
|
||||
pub fn copy_from_slice(data: &[u8]) -> Self {
|
||||
data.to_vec().into()
|
||||
@@ -279,14 +225,14 @@ impl Bytes {
|
||||
///
|
||||
/// Requires that `begin <= end` and `end <= self.len()`, otherwise slicing
|
||||
/// will panic.
|
||||
pub fn slice(&self, range: impl RangeBounds<usize>) -> Self {
|
||||
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.checked_add(1).expect("out of range"),
|
||||
Bound::Excluded(&n) => n + 1,
|
||||
Bound::Unbounded => 0,
|
||||
};
|
||||
|
||||
@@ -316,7 +262,7 @@ impl Bytes {
|
||||
let mut ret = self.clone();
|
||||
|
||||
ret.len = end - begin;
|
||||
ret.ptr = unsafe { ret.ptr.add(begin) };
|
||||
ret.ptr = unsafe { ret.ptr.offset(begin as isize) };
|
||||
|
||||
ret
|
||||
}
|
||||
@@ -346,7 +292,7 @@ impl Bytes {
|
||||
///
|
||||
/// 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]) -> Self {
|
||||
pub fn slice_ref(&self, subset: &[u8]) -> Bytes {
|
||||
// Empty slice and empty Bytes may have their pointers reset
|
||||
// so explicitly allow empty slice to be a subslice of any slice.
|
||||
if subset.is_empty() {
|
||||
@@ -362,15 +308,15 @@ impl Bytes {
|
||||
assert!(
|
||||
sub_p >= bytes_p,
|
||||
"subset pointer ({:p}) is smaller than self pointer ({:p})",
|
||||
subset.as_ptr(),
|
||||
self.as_ptr(),
|
||||
sub_p as *const u8,
|
||||
bytes_p as *const u8,
|
||||
);
|
||||
assert!(
|
||||
sub_p + sub_len <= bytes_p + bytes_len,
|
||||
"subset is out of bounds: self = ({:p}, {}), subset = ({:p}, {})",
|
||||
self.as_ptr(),
|
||||
bytes_p as *const u8,
|
||||
bytes_len,
|
||||
subset.as_ptr(),
|
||||
sub_p as *const u8,
|
||||
sub_len,
|
||||
);
|
||||
|
||||
@@ -382,9 +328,7 @@ impl Bytes {
|
||||
/// Splits the bytes into two at the given index.
|
||||
///
|
||||
/// Afterwards `self` contains elements `[0, at)`, and the returned `Bytes`
|
||||
/// contains elements `[at, len)`. It's guaranteed that the memory does not
|
||||
/// move, that is, the address of `self` does not change, and the address of
|
||||
/// the returned slice is `at` bytes after that.
|
||||
/// contains elements `[at, len)`.
|
||||
///
|
||||
/// This is an `O(1)` operation that just increases the reference count and
|
||||
/// sets a few indices.
|
||||
@@ -405,15 +349,7 @@ impl Bytes {
|
||||
///
|
||||
/// Panics if `at > len`.
|
||||
#[must_use = "consider Bytes::truncate if you don't need the other half"]
|
||||
pub fn split_off(&mut self, at: usize) -> Self {
|
||||
if at == self.len() {
|
||||
return Bytes::new_empty_with_ptr(self.ptr.wrapping_add(at));
|
||||
}
|
||||
|
||||
if at == 0 {
|
||||
return mem::replace(self, Bytes::new_empty_with_ptr(self.ptr));
|
||||
}
|
||||
|
||||
pub fn split_off(&mut self, at: usize) -> Bytes {
|
||||
assert!(
|
||||
at <= self.len(),
|
||||
"split_off out of bounds: {:?} <= {:?}",
|
||||
@@ -421,6 +357,14 @@ impl Bytes {
|
||||
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;
|
||||
@@ -454,16 +398,7 @@ impl Bytes {
|
||||
///
|
||||
/// Panics if `at > len`.
|
||||
#[must_use = "consider Bytes::advance if you don't need the other half"]
|
||||
pub fn split_to(&mut self, at: usize) -> Self {
|
||||
if at == self.len() {
|
||||
let end_ptr = self.ptr.wrapping_add(at);
|
||||
return mem::replace(self, Bytes::new_empty_with_ptr(end_ptr));
|
||||
}
|
||||
|
||||
if at == 0 {
|
||||
return Bytes::new_empty_with_ptr(self.ptr);
|
||||
}
|
||||
|
||||
pub fn split_to(&mut self, at: usize) -> Bytes {
|
||||
assert!(
|
||||
at <= self.len(),
|
||||
"split_to out of bounds: {:?} <= {:?}",
|
||||
@@ -471,6 +406,14 @@ impl Bytes {
|
||||
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) };
|
||||
@@ -485,7 +428,7 @@ impl Bytes {
|
||||
/// If `len` is greater than the buffer's current length, this has no
|
||||
/// effect.
|
||||
///
|
||||
/// The [split_off](`Self::split_off()`) method can emulate `truncate`, but this causes the
|
||||
/// The [`split_off`] method can emulate `truncate`, but this causes the
|
||||
/// excess bytes to be returned instead of dropped.
|
||||
///
|
||||
/// # Examples
|
||||
@@ -497,6 +440,8 @@ impl Bytes {
|
||||
/// 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 {
|
||||
@@ -529,29 +474,6 @@ impl Bytes {
|
||||
self.truncate(0);
|
||||
}
|
||||
|
||||
/// Try to convert self into `BytesMut`.
|
||||
///
|
||||
/// If `self` is unique for the entire original buffer, this will succeed
|
||||
/// and return a `BytesMut` with the contents of `self` without copying.
|
||||
/// If `self` is not unique for the entire original buffer, this will fail
|
||||
/// and return self.
|
||||
///
|
||||
/// # Examples
|
||||
///
|
||||
/// ```
|
||||
/// use bytes::{Bytes, BytesMut};
|
||||
///
|
||||
/// let bytes = Bytes::from(b"hello".to_vec());
|
||||
/// assert_eq!(bytes.try_into_mut(), Ok(BytesMut::from(&b"hello"[..])));
|
||||
/// ```
|
||||
pub fn try_into_mut(self) -> Result<BytesMut, Bytes> {
|
||||
if self.is_unique() {
|
||||
Ok(self.into())
|
||||
} else {
|
||||
Err(self)
|
||||
}
|
||||
}
|
||||
|
||||
#[inline]
|
||||
pub(crate) unsafe fn with_vtable(
|
||||
ptr: *const u8,
|
||||
@@ -579,7 +501,7 @@ impl Bytes {
|
||||
// should already be asserted, but debug assert for tests
|
||||
debug_assert!(self.len >= by, "internal: inc_start out of bounds");
|
||||
self.len -= by;
|
||||
self.ptr = self.ptr.add(by);
|
||||
self.ptr = self.ptr.offset(by as isize);
|
||||
}
|
||||
}
|
||||
|
||||
@@ -608,7 +530,7 @@ impl Buf for Bytes {
|
||||
}
|
||||
|
||||
#[inline]
|
||||
fn chunk(&self) -> &[u8] {
|
||||
fn bytes(&self) -> &[u8] {
|
||||
self.as_slice()
|
||||
}
|
||||
|
||||
@@ -626,8 +548,14 @@ impl Buf for Bytes {
|
||||
}
|
||||
}
|
||||
|
||||
fn copy_to_bytes(&mut self, len: usize) -> Self {
|
||||
self.split_to(len)
|
||||
fn copy_to_bytes(&mut self, len: usize) -> crate::Bytes {
|
||||
if len == self.remaining() {
|
||||
core::mem::replace(self, Bytes::new())
|
||||
} else {
|
||||
let ret = self.slice(..len);
|
||||
self.advance(len);
|
||||
ret
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
@@ -676,7 +604,7 @@ impl<'a> IntoIterator for &'a Bytes {
|
||||
type IntoIter = core::slice::Iter<'a, u8>;
|
||||
|
||||
fn into_iter(self) -> Self::IntoIter {
|
||||
self.as_slice().iter()
|
||||
self.as_slice().into_iter()
|
||||
}
|
||||
}
|
||||
|
||||
@@ -758,7 +686,7 @@ impl PartialOrd<Bytes> for str {
|
||||
|
||||
impl PartialEq<Vec<u8>> for Bytes {
|
||||
fn eq(&self, other: &Vec<u8>) -> bool {
|
||||
*self == other[..]
|
||||
*self == &other[..]
|
||||
}
|
||||
}
|
||||
|
||||
@@ -782,7 +710,7 @@ impl PartialOrd<Bytes> for Vec<u8> {
|
||||
|
||||
impl PartialEq<String> for Bytes {
|
||||
fn eq(&self, other: &String) -> bool {
|
||||
*self == other[..]
|
||||
*self == &other[..]
|
||||
}
|
||||
}
|
||||
|
||||
@@ -869,105 +797,43 @@ impl From<&'static str> for Bytes {
|
||||
|
||||
impl From<Vec<u8>> for Bytes {
|
||||
fn from(vec: Vec<u8>) -> Bytes {
|
||||
let mut vec = ManuallyDrop::new(vec);
|
||||
let ptr = vec.as_mut_ptr();
|
||||
let len = vec.len();
|
||||
let cap = vec.capacity();
|
||||
|
||||
// Avoid an extra allocation if possible.
|
||||
if len == cap {
|
||||
let vec = ManuallyDrop::into_inner(vec);
|
||||
return Bytes::from(vec.into_boxed_slice());
|
||||
}
|
||||
|
||||
let shared = Box::new(Shared {
|
||||
buf: ptr,
|
||||
cap,
|
||||
ref_cnt: AtomicUsize::new(1),
|
||||
});
|
||||
|
||||
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),
|
||||
"internal: Box<Shared> should have an aligned pointer",
|
||||
);
|
||||
Bytes {
|
||||
ptr,
|
||||
len,
|
||||
data: AtomicPtr::new(shared as _),
|
||||
vtable: &SHARED_VTABLE,
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
impl From<Box<[u8]>> for Bytes {
|
||||
fn from(slice: Box<[u8]>) -> Bytes {
|
||||
// Box<[u8]> doesn't contain a heap allocation for empty slices,
|
||||
// into_boxed_slice doesn't return a heap allocation for empty vectors,
|
||||
// so the pointer isn't aligned enough for the KIND_VEC stashing to
|
||||
// work.
|
||||
if slice.is_empty() {
|
||||
if vec.is_empty() {
|
||||
return Bytes::new();
|
||||
}
|
||||
|
||||
let slice = vec.into_boxed_slice();
|
||||
let len = slice.len();
|
||||
let ptr = Box::into_raw(slice) as *mut u8;
|
||||
let ptr = slice.as_ptr();
|
||||
drop(Box::into_raw(slice));
|
||||
|
||||
if ptr as usize & 0x1 == 0 {
|
||||
let data = ptr_map(ptr, |addr| addr | KIND_VEC);
|
||||
let data = ptr as usize | KIND_VEC;
|
||||
Bytes {
|
||||
ptr,
|
||||
len,
|
||||
data: AtomicPtr::new(data.cast()),
|
||||
data: AtomicPtr::new(data as *mut _),
|
||||
vtable: &PROMOTABLE_EVEN_VTABLE,
|
||||
}
|
||||
} else {
|
||||
Bytes {
|
||||
ptr,
|
||||
len,
|
||||
data: AtomicPtr::new(ptr.cast()),
|
||||
data: AtomicPtr::new(ptr as *mut _),
|
||||
vtable: &PROMOTABLE_ODD_VTABLE,
|
||||
}
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
impl From<Bytes> for BytesMut {
|
||||
/// Convert self into `BytesMut`.
|
||||
///
|
||||
/// If `bytes` is unique for the entire original buffer, this will return a
|
||||
/// `BytesMut` with the contents of `bytes` without copying.
|
||||
/// If `bytes` is not unique for the entire original buffer, this will make
|
||||
/// a copy of `bytes` subset of the original buffer in a new `BytesMut`.
|
||||
///
|
||||
/// # Examples
|
||||
///
|
||||
/// ```
|
||||
/// use bytes::{Bytes, BytesMut};
|
||||
///
|
||||
/// let bytes = Bytes::from(b"hello".to_vec());
|
||||
/// assert_eq!(BytesMut::from(bytes), BytesMut::from(&b"hello"[..]));
|
||||
/// ```
|
||||
fn from(bytes: Bytes) -> Self {
|
||||
let bytes = ManuallyDrop::new(bytes);
|
||||
unsafe { (bytes.vtable.to_mut)(&bytes.data, bytes.ptr, bytes.len) }
|
||||
}
|
||||
}
|
||||
|
||||
impl From<String> for Bytes {
|
||||
fn from(s: String) -> Bytes {
|
||||
Bytes::from(s.into_bytes())
|
||||
}
|
||||
}
|
||||
|
||||
impl From<Bytes> for Vec<u8> {
|
||||
fn from(bytes: Bytes) -> Vec<u8> {
|
||||
let bytes = ManuallyDrop::new(bytes);
|
||||
unsafe { (bytes.vtable.to_vec)(&bytes.data, bytes.ptr, bytes.len) }
|
||||
}
|
||||
}
|
||||
|
||||
// ===== impl Vtable =====
|
||||
|
||||
impl fmt::Debug for Vtable {
|
||||
@@ -983,9 +849,6 @@ impl fmt::Debug for Vtable {
|
||||
|
||||
const STATIC_VTABLE: Vtable = Vtable {
|
||||
clone: static_clone,
|
||||
to_vec: static_to_vec,
|
||||
to_mut: static_to_mut,
|
||||
is_unique: static_is_unique,
|
||||
drop: static_drop,
|
||||
};
|
||||
|
||||
@@ -994,20 +857,6 @@ unsafe fn static_clone(_: &AtomicPtr<()>, ptr: *const u8, len: usize) -> Bytes {
|
||||
Bytes::from_static(slice)
|
||||
}
|
||||
|
||||
unsafe fn static_to_vec(_: &AtomicPtr<()>, ptr: *const u8, len: usize) -> Vec<u8> {
|
||||
let slice = slice::from_raw_parts(ptr, len);
|
||||
slice.to_vec()
|
||||
}
|
||||
|
||||
unsafe fn static_to_mut(_: &AtomicPtr<()>, ptr: *const u8, len: usize) -> BytesMut {
|
||||
let slice = slice::from_raw_parts(ptr, len);
|
||||
BytesMut::from(slice)
|
||||
}
|
||||
|
||||
fn static_is_unique(_: &AtomicPtr<()>) -> bool {
|
||||
false
|
||||
}
|
||||
|
||||
unsafe fn static_drop(_: &mut AtomicPtr<()>, _: *const u8, _: usize) {
|
||||
// nothing to drop for &'static [u8]
|
||||
}
|
||||
@@ -1016,17 +865,11 @@ unsafe fn static_drop(_: &mut AtomicPtr<()>, _: *const u8, _: usize) {
|
||||
|
||||
static PROMOTABLE_EVEN_VTABLE: Vtable = Vtable {
|
||||
clone: promotable_even_clone,
|
||||
to_vec: promotable_even_to_vec,
|
||||
to_mut: promotable_even_to_mut,
|
||||
is_unique: promotable_is_unique,
|
||||
drop: promotable_even_drop,
|
||||
};
|
||||
|
||||
static PROMOTABLE_ODD_VTABLE: Vtable = Vtable {
|
||||
clone: promotable_odd_clone,
|
||||
to_vec: promotable_odd_to_vec,
|
||||
to_mut: promotable_odd_to_mut,
|
||||
is_unique: promotable_is_unique,
|
||||
drop: promotable_odd_drop,
|
||||
};
|
||||
|
||||
@@ -1035,92 +878,25 @@ unsafe fn promotable_even_clone(data: &AtomicPtr<()>, ptr: *const u8, len: usize
|
||||
let kind = shared as usize & KIND_MASK;
|
||||
|
||||
if kind == KIND_ARC {
|
||||
shallow_clone_arc(shared.cast(), ptr, len)
|
||||
shallow_clone_arc(shared as _, ptr, len)
|
||||
} else {
|
||||
debug_assert_eq!(kind, KIND_VEC);
|
||||
let buf = ptr_map(shared.cast(), |addr| addr & !KIND_MASK);
|
||||
let buf = (shared as usize & !KIND_MASK) as *mut u8;
|
||||
shallow_clone_vec(data, shared, buf, ptr, len)
|
||||
}
|
||||
}
|
||||
|
||||
unsafe fn promotable_to_vec(
|
||||
data: &AtomicPtr<()>,
|
||||
ptr: *const u8,
|
||||
len: usize,
|
||||
f: fn(*mut ()) -> *mut u8,
|
||||
) -> Vec<u8> {
|
||||
let shared = data.load(Ordering::Acquire);
|
||||
let kind = shared as usize & KIND_MASK;
|
||||
|
||||
if kind == KIND_ARC {
|
||||
shared_to_vec_impl(shared.cast(), ptr, len)
|
||||
} else {
|
||||
// If Bytes holds a Vec, then the offset must be 0.
|
||||
debug_assert_eq!(kind, KIND_VEC);
|
||||
|
||||
let buf = f(shared);
|
||||
|
||||
let cap = offset_from(ptr, buf) + len;
|
||||
|
||||
// Copy back buffer
|
||||
ptr::copy(ptr, buf, len);
|
||||
|
||||
Vec::from_raw_parts(buf, len, cap)
|
||||
}
|
||||
}
|
||||
|
||||
unsafe fn promotable_to_mut(
|
||||
data: &AtomicPtr<()>,
|
||||
ptr: *const u8,
|
||||
len: usize,
|
||||
f: fn(*mut ()) -> *mut u8,
|
||||
) -> BytesMut {
|
||||
let shared = data.load(Ordering::Acquire);
|
||||
let kind = shared as usize & KIND_MASK;
|
||||
|
||||
if kind == KIND_ARC {
|
||||
shared_to_mut_impl(shared.cast(), ptr, len)
|
||||
} else {
|
||||
// KIND_VEC is a view of an underlying buffer at a certain offset.
|
||||
// The ptr + len always represents the end of that buffer.
|
||||
// Before truncating it, it is first promoted to KIND_ARC.
|
||||
// Thus, we can safely reconstruct a Vec from it without leaking memory.
|
||||
debug_assert_eq!(kind, KIND_VEC);
|
||||
|
||||
let buf = f(shared);
|
||||
let off = offset_from(ptr, buf);
|
||||
let cap = off + len;
|
||||
let v = Vec::from_raw_parts(buf, cap, cap);
|
||||
|
||||
let mut b = BytesMut::from_vec(v);
|
||||
b.advance_unchecked(off);
|
||||
b
|
||||
}
|
||||
}
|
||||
|
||||
unsafe fn promotable_even_to_vec(data: &AtomicPtr<()>, ptr: *const u8, len: usize) -> Vec<u8> {
|
||||
promotable_to_vec(data, ptr, len, |shared| {
|
||||
ptr_map(shared.cast(), |addr| addr & !KIND_MASK)
|
||||
})
|
||||
}
|
||||
|
||||
unsafe fn promotable_even_to_mut(data: &AtomicPtr<()>, ptr: *const u8, len: usize) -> BytesMut {
|
||||
promotable_to_mut(data, ptr, len, |shared| {
|
||||
ptr_map(shared.cast(), |addr| addr & !KIND_MASK)
|
||||
})
|
||||
}
|
||||
|
||||
unsafe fn promotable_even_drop(data: &mut AtomicPtr<()>, ptr: *const u8, len: usize) {
|
||||
data.with_mut(|shared| {
|
||||
let shared = *shared;
|
||||
let kind = shared as usize & KIND_MASK;
|
||||
|
||||
if kind == KIND_ARC {
|
||||
release_shared(shared.cast());
|
||||
release_shared(shared as *mut Shared);
|
||||
} else {
|
||||
debug_assert_eq!(kind, KIND_VEC);
|
||||
let buf = ptr_map(shared.cast(), |addr| addr & !KIND_MASK);
|
||||
free_boxed_slice(buf, ptr, len);
|
||||
let buf = (shared as usize & !KIND_MASK) as *mut u8;
|
||||
drop(rebuild_boxed_slice(buf, ptr, len));
|
||||
}
|
||||
});
|
||||
}
|
||||
@@ -1133,65 +909,38 @@ unsafe fn promotable_odd_clone(data: &AtomicPtr<()>, ptr: *const u8, len: usize)
|
||||
shallow_clone_arc(shared as _, ptr, len)
|
||||
} else {
|
||||
debug_assert_eq!(kind, KIND_VEC);
|
||||
shallow_clone_vec(data, shared, shared.cast(), ptr, len)
|
||||
shallow_clone_vec(data, shared, shared as *mut u8, ptr, len)
|
||||
}
|
||||
}
|
||||
|
||||
unsafe fn promotable_odd_to_vec(data: &AtomicPtr<()>, ptr: *const u8, len: usize) -> Vec<u8> {
|
||||
promotable_to_vec(data, ptr, len, |shared| shared.cast())
|
||||
}
|
||||
|
||||
unsafe fn promotable_odd_to_mut(data: &AtomicPtr<()>, ptr: *const u8, len: usize) -> BytesMut {
|
||||
promotable_to_mut(data, ptr, len, |shared| shared.cast())
|
||||
}
|
||||
|
||||
unsafe fn promotable_odd_drop(data: &mut AtomicPtr<()>, ptr: *const u8, len: usize) {
|
||||
data.with_mut(|shared| {
|
||||
let shared = *shared;
|
||||
let kind = shared as usize & KIND_MASK;
|
||||
|
||||
if kind == KIND_ARC {
|
||||
release_shared(shared.cast());
|
||||
release_shared(shared as *mut Shared);
|
||||
} else {
|
||||
debug_assert_eq!(kind, KIND_VEC);
|
||||
|
||||
free_boxed_slice(shared.cast(), ptr, len);
|
||||
drop(rebuild_boxed_slice(shared as *mut u8, ptr, len));
|
||||
}
|
||||
});
|
||||
}
|
||||
|
||||
unsafe fn promotable_is_unique(data: &AtomicPtr<()>) -> bool {
|
||||
let shared = data.load(Ordering::Acquire);
|
||||
let kind = shared as usize & KIND_MASK;
|
||||
|
||||
if kind == KIND_ARC {
|
||||
let ref_cnt = (*shared.cast::<Shared>()).ref_cnt.load(Ordering::Relaxed);
|
||||
ref_cnt == 1
|
||||
} else {
|
||||
true
|
||||
}
|
||||
}
|
||||
|
||||
unsafe fn free_boxed_slice(buf: *mut u8, offset: *const u8, len: usize) {
|
||||
let cap = offset_from(offset, buf) + len;
|
||||
dealloc(buf, Layout::from_size_align(cap, 1).unwrap())
|
||||
unsafe fn rebuild_boxed_slice(buf: *mut u8, offset: *const u8, len: usize) -> Box<[u8]> {
|
||||
let cap = (offset as usize - buf as usize) + len;
|
||||
Box::from_raw(slice::from_raw_parts_mut(buf, cap))
|
||||
}
|
||||
|
||||
// ===== impl SharedVtable =====
|
||||
|
||||
struct Shared {
|
||||
// Holds arguments to dealloc upon Drop, but otherwise doesn't use them
|
||||
buf: *mut u8,
|
||||
cap: usize,
|
||||
// holds vec for drop, but otherwise doesnt access it
|
||||
_vec: Vec<u8>,
|
||||
ref_cnt: AtomicUsize,
|
||||
}
|
||||
|
||||
impl Drop for Shared {
|
||||
fn drop(&mut self) {
|
||||
unsafe { dealloc(self.buf, Layout::from_size_align(self.cap, 1).unwrap()) }
|
||||
}
|
||||
}
|
||||
|
||||
// Assert that the alignment of `Shared` is divisible by 2.
|
||||
// This is a necessary invariant since we depend on allocating `Shared` a
|
||||
// shared object to implicitly carry the `KIND_ARC` flag in its pointer.
|
||||
@@ -1200,9 +949,6 @@ const _: [(); 0 - mem::align_of::<Shared>() % 2] = []; // Assert that the alignm
|
||||
|
||||
static SHARED_VTABLE: Vtable = Vtable {
|
||||
clone: shared_clone,
|
||||
to_vec: shared_to_vec,
|
||||
to_mut: shared_to_mut,
|
||||
is_unique: shared_is_unique,
|
||||
drop: shared_drop,
|
||||
};
|
||||
|
||||
@@ -1215,87 +961,9 @@ unsafe fn shared_clone(data: &AtomicPtr<()>, ptr: *const u8, len: usize) -> Byte
|
||||
shallow_clone_arc(shared as _, ptr, len)
|
||||
}
|
||||
|
||||
unsafe fn shared_to_vec_impl(shared: *mut Shared, ptr: *const u8, len: usize) -> Vec<u8> {
|
||||
// Check that the ref_cnt is 1 (unique).
|
||||
//
|
||||
// If it is unique, then it is set to 0 with AcqRel fence for the same
|
||||
// reason in release_shared.
|
||||
//
|
||||
// Otherwise, we take the other branch and call release_shared.
|
||||
if (*shared)
|
||||
.ref_cnt
|
||||
.compare_exchange(1, 0, Ordering::AcqRel, Ordering::Relaxed)
|
||||
.is_ok()
|
||||
{
|
||||
// Deallocate the `Shared` instance without running its destructor.
|
||||
let shared = *Box::from_raw(shared);
|
||||
let shared = ManuallyDrop::new(shared);
|
||||
let buf = shared.buf;
|
||||
let cap = shared.cap;
|
||||
|
||||
// Copy back buffer
|
||||
ptr::copy(ptr, buf, len);
|
||||
|
||||
Vec::from_raw_parts(buf, len, cap)
|
||||
} else {
|
||||
let v = slice::from_raw_parts(ptr, len).to_vec();
|
||||
release_shared(shared);
|
||||
v
|
||||
}
|
||||
}
|
||||
|
||||
unsafe fn shared_to_vec(data: &AtomicPtr<()>, ptr: *const u8, len: usize) -> Vec<u8> {
|
||||
shared_to_vec_impl(data.load(Ordering::Relaxed).cast(), ptr, len)
|
||||
}
|
||||
|
||||
unsafe fn shared_to_mut_impl(shared: *mut Shared, ptr: *const u8, len: usize) -> BytesMut {
|
||||
// The goal is to check if the current handle is the only handle
|
||||
// that currently has access to the buffer. This is done by
|
||||
// checking if the `ref_cnt` is currently 1.
|
||||
//
|
||||
// The `Acquire` ordering synchronizes with the `Release` as
|
||||
// part of the `fetch_sub` in `release_shared`. The `fetch_sub`
|
||||
// operation guarantees that any mutations done in other threads
|
||||
// are ordered before the `ref_cnt` is decremented. As such,
|
||||
// this `Acquire` will guarantee that those mutations are
|
||||
// visible to the current thread.
|
||||
//
|
||||
// Otherwise, we take the other branch, copy the data and call `release_shared`.
|
||||
if (*shared).ref_cnt.load(Ordering::Acquire) == 1 {
|
||||
// Deallocate the `Shared` instance without running its destructor.
|
||||
let shared = *Box::from_raw(shared);
|
||||
let shared = ManuallyDrop::new(shared);
|
||||
let buf = shared.buf;
|
||||
let cap = shared.cap;
|
||||
|
||||
// Rebuild Vec
|
||||
let off = offset_from(ptr, buf);
|
||||
let v = Vec::from_raw_parts(buf, len + off, cap);
|
||||
|
||||
let mut b = BytesMut::from_vec(v);
|
||||
b.advance_unchecked(off);
|
||||
b
|
||||
} else {
|
||||
// Copy the data from Shared in a new Vec, then release it
|
||||
let v = slice::from_raw_parts(ptr, len).to_vec();
|
||||
release_shared(shared);
|
||||
BytesMut::from_vec(v)
|
||||
}
|
||||
}
|
||||
|
||||
unsafe fn shared_to_mut(data: &AtomicPtr<()>, ptr: *const u8, len: usize) -> BytesMut {
|
||||
shared_to_mut_impl(data.load(Ordering::Relaxed).cast(), ptr, len)
|
||||
}
|
||||
|
||||
pub(crate) unsafe fn shared_is_unique(data: &AtomicPtr<()>) -> bool {
|
||||
let shared = data.load(Ordering::Acquire);
|
||||
let ref_cnt = (*shared.cast::<Shared>()).ref_cnt.load(Ordering::Relaxed);
|
||||
ref_cnt == 1
|
||||
}
|
||||
|
||||
unsafe fn shared_drop(data: &mut AtomicPtr<()>, _ptr: *const u8, _len: usize) {
|
||||
data.with_mut(|shared| {
|
||||
release_shared(shared.cast());
|
||||
release_shared(*shared as *mut Shared);
|
||||
});
|
||||
}
|
||||
|
||||
@@ -1322,7 +990,7 @@ unsafe fn shallow_clone_vec(
|
||||
offset: *const u8,
|
||||
len: usize,
|
||||
) -> Bytes {
|
||||
// If the buffer is still tracked in a `Vec<u8>`. It is time to
|
||||
// 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.
|
||||
|
||||
@@ -1333,9 +1001,9 @@ unsafe fn shallow_clone_vec(
|
||||
// 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_boxed_slice(buf, offset, len).into_vec();
|
||||
let shared = Box::new(Shared {
|
||||
buf,
|
||||
cap: offset_from(offset, buf) + len,
|
||||
_vec: vec,
|
||||
// Initialize refcount to 2. One for this reference, and one
|
||||
// for the new clone that will be returned from
|
||||
// `shallow_clone`.
|
||||
@@ -1355,35 +1023,33 @@ unsafe fn shallow_clone_vec(
|
||||
// `Release` is used synchronize with other threads that
|
||||
// will load the `arc` field.
|
||||
//
|
||||
// If the `compare_exchange` fails, then the thread lost the
|
||||
// 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_exchange`
|
||||
// ordering will synchronize with the `compare_and_swap`
|
||||
// that happened in the other thread and the `Shared`
|
||||
// pointed to by `actual` will be visible.
|
||||
match atom.compare_exchange(ptr as _, shared as _, Ordering::AcqRel, Ordering::Acquire) {
|
||||
Ok(actual) => {
|
||||
debug_assert!(actual as usize == ptr as usize);
|
||||
// The upgrade was successful, the new handle can be
|
||||
// returned.
|
||||
Bytes {
|
||||
ptr: offset,
|
||||
len,
|
||||
data: AtomicPtr::new(shared as _),
|
||||
vtable: &SHARED_VTABLE,
|
||||
}
|
||||
}
|
||||
Err(actual) => {
|
||||
// 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);
|
||||
let actual = atom.compare_and_swap(ptr as _, shared as _, Ordering::AcqRel);
|
||||
|
||||
// Buffer already promoted to shared storage, so increment ref
|
||||
// count.
|
||||
shallow_clone_arc(actual as _, offset, len)
|
||||
}
|
||||
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) {
|
||||
@@ -1409,44 +1075,10 @@ unsafe fn release_shared(ptr: *mut Shared) {
|
||||
// > "acquire" operation before deleting the object.
|
||||
//
|
||||
// [1]: (www.boost.org/doc/libs/1_55_0/doc/html/atomic/usage_examples.html)
|
||||
//
|
||||
// Thread sanitizer does not support atomic fences. Use an atomic load
|
||||
// instead.
|
||||
(*ptr).ref_cnt.load(Ordering::Acquire);
|
||||
atomic::fence(Ordering::Acquire);
|
||||
|
||||
// Drop the data
|
||||
drop(Box::from_raw(ptr));
|
||||
}
|
||||
|
||||
// Ideally we would always use this version of `ptr_map` since it is strict
|
||||
// provenance compatible, but it results in worse codegen. We will however still
|
||||
// use it on miri because it gives better diagnostics for people who test bytes
|
||||
// code with miri.
|
||||
//
|
||||
// See https://github.com/tokio-rs/bytes/pull/545 for more info.
|
||||
#[cfg(miri)]
|
||||
fn ptr_map<F>(ptr: *mut u8, f: F) -> *mut u8
|
||||
where
|
||||
F: FnOnce(usize) -> usize,
|
||||
{
|
||||
let old_addr = ptr as usize;
|
||||
let new_addr = f(old_addr);
|
||||
let diff = new_addr.wrapping_sub(old_addr);
|
||||
ptr.wrapping_add(diff)
|
||||
}
|
||||
|
||||
#[cfg(not(miri))]
|
||||
fn ptr_map<F>(ptr: *mut u8, f: F) -> *mut u8
|
||||
where
|
||||
F: FnOnce(usize) -> usize,
|
||||
{
|
||||
let old_addr = ptr as usize;
|
||||
let new_addr = f(old_addr);
|
||||
new_addr as *mut u8
|
||||
}
|
||||
|
||||
fn without_provenance(ptr: usize) -> *const u8 {
|
||||
core::ptr::null::<u8>().wrapping_add(ptr)
|
||||
Box::from_raw(ptr);
|
||||
}
|
||||
|
||||
// compile-fails
|
||||
|
||||
+203
-540
File diff suppressed because it is too large
Load Diff
+3
-3
@@ -25,7 +25,7 @@ impl Debug for BytesRef<'_> {
|
||||
} else if b == b'\0' {
|
||||
write!(f, "\\0")?;
|
||||
// ASCII printable
|
||||
} else if (0x20..0x7f).contains(&b) {
|
||||
} else if b >= 0x20 && b < 0x7f {
|
||||
write!(f, "{}", b as char)?;
|
||||
} else {
|
||||
write!(f, "\\x{:02x}", b)?;
|
||||
@@ -38,12 +38,12 @@ impl Debug for BytesRef<'_> {
|
||||
|
||||
impl Debug for Bytes {
|
||||
fn fmt(&self, f: &mut Formatter<'_>) -> Result {
|
||||
Debug::fmt(&BytesRef(self.as_ref()), f)
|
||||
Debug::fmt(&BytesRef(&self.as_ref()), f)
|
||||
}
|
||||
}
|
||||
|
||||
impl Debug for BytesMut {
|
||||
fn fmt(&self, f: &mut Formatter<'_>) -> Result {
|
||||
Debug::fmt(&BytesRef(self.as_ref()), f)
|
||||
Debug::fmt(&BytesRef(&self.as_ref()), f)
|
||||
}
|
||||
}
|
||||
|
||||
+9
-57
@@ -1,18 +1,20 @@
|
||||
#![allow(unknown_lints, unexpected_cfgs)]
|
||||
#![warn(missing_docs, missing_debug_implementations, rust_2018_idioms)]
|
||||
#![doc(test(
|
||||
no_crate_inject,
|
||||
attr(deny(warnings, rust_2018_idioms), allow(dead_code, unused_variables))
|
||||
))]
|
||||
#![doc(html_root_url = "https://docs.rs/bytes/0.6.0")]
|
||||
#![no_std]
|
||||
#![cfg_attr(docsrs, feature(doc_cfg))]
|
||||
|
||||
//! Provides abstractions for working with bytes.
|
||||
//!
|
||||
//! The `bytes` crate provides an efficient byte buffer structure
|
||||
//! ([`Bytes`]) and traits for working with buffer
|
||||
//! ([`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
|
||||
@@ -50,7 +52,9 @@
|
||||
//! `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](`Bytes`) for more details.
|
||||
//! See the [struct docs] for more details.
|
||||
//!
|
||||
//! [struct docs]: struct.Bytes.html
|
||||
//!
|
||||
//! # `Buf`, `BufMut`
|
||||
//!
|
||||
@@ -66,7 +70,7 @@
|
||||
//! ## 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
|
||||
//! 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`
|
||||
@@ -111,55 +115,3 @@ fn abort() -> ! {
|
||||
panic!("abort");
|
||||
}
|
||||
}
|
||||
|
||||
#[inline(always)]
|
||||
#[cfg(feature = "std")]
|
||||
fn saturating_sub_usize_u64(a: usize, b: u64) -> usize {
|
||||
use core::convert::TryFrom;
|
||||
match usize::try_from(b) {
|
||||
Ok(b) => a.saturating_sub(b),
|
||||
Err(_) => 0,
|
||||
}
|
||||
}
|
||||
|
||||
#[inline(always)]
|
||||
#[cfg(feature = "std")]
|
||||
fn min_u64_usize(a: u64, b: usize) -> usize {
|
||||
use core::convert::TryFrom;
|
||||
match usize::try_from(a) {
|
||||
Ok(a) => usize::min(a, b),
|
||||
Err(_) => b,
|
||||
}
|
||||
}
|
||||
|
||||
/// Panic with a nice error message.
|
||||
#[cold]
|
||||
fn panic_advance(idx: usize, len: usize) -> ! {
|
||||
panic!(
|
||||
"advance out of bounds: the len is {} but advancing by {}",
|
||||
len, idx
|
||||
);
|
||||
}
|
||||
|
||||
#[cold]
|
||||
fn panic_does_not_fit(size: usize, nbytes: usize) -> ! {
|
||||
panic!(
|
||||
"size too large: the integer type can fit {} bytes, but nbytes is {}",
|
||||
size, nbytes
|
||||
);
|
||||
}
|
||||
|
||||
/// Precondition: dst >= original
|
||||
///
|
||||
/// The following line is equivalent to:
|
||||
///
|
||||
/// ```rust,ignore
|
||||
/// self.ptr.as_ptr().offset_from(ptr) as usize;
|
||||
/// ```
|
||||
///
|
||||
/// But due to min rust is 1.39 and it is only stabilized
|
||||
/// in 1.47, we cannot use it.
|
||||
#[inline]
|
||||
fn offset_from(dst: *const u8, original: *const u8) -> usize {
|
||||
dst as usize - original as usize
|
||||
}
|
||||
|
||||
+2
-2
@@ -1,7 +1,7 @@
|
||||
#[cfg(not(all(test, loom)))]
|
||||
pub(crate) mod sync {
|
||||
pub(crate) mod atomic {
|
||||
pub(crate) use core::sync::atomic::{AtomicPtr, AtomicUsize, Ordering};
|
||||
pub(crate) use core::sync::atomic::{fence, AtomicPtr, AtomicUsize, Ordering};
|
||||
|
||||
pub(crate) trait AtomicMut<T> {
|
||||
fn with_mut<F, R>(&mut self, f: F) -> R
|
||||
@@ -23,7 +23,7 @@ pub(crate) mod sync {
|
||||
#[cfg(all(test, loom))]
|
||||
pub(crate) mod sync {
|
||||
pub(crate) mod atomic {
|
||||
pub(crate) use loom::sync::atomic::{AtomicPtr, AtomicUsize, Ordering};
|
||||
pub(crate) use loom::sync::atomic::{fence, AtomicPtr, AtomicUsize, Ordering};
|
||||
|
||||
pub(crate) trait AtomicMut<T> {}
|
||||
}
|
||||
|
||||
+8
-22
@@ -9,17 +9,17 @@ fn test_fresh_cursor_vec() {
|
||||
let mut buf = &b"hello"[..];
|
||||
|
||||
assert_eq!(buf.remaining(), 5);
|
||||
assert_eq!(buf.chunk(), b"hello");
|
||||
assert_eq!(buf.bytes(), b"hello");
|
||||
|
||||
buf.advance(2);
|
||||
|
||||
assert_eq!(buf.remaining(), 3);
|
||||
assert_eq!(buf.chunk(), b"llo");
|
||||
assert_eq!(buf.bytes(), b"llo");
|
||||
|
||||
buf.advance(3);
|
||||
|
||||
assert_eq!(buf.remaining(), 0);
|
||||
assert_eq!(buf.chunk(), b"");
|
||||
assert_eq!(buf.bytes(), b"");
|
||||
}
|
||||
|
||||
#[test]
|
||||
@@ -36,19 +36,6 @@ fn test_get_u16() {
|
||||
assert_eq!(0x5421, buf.get_u16_le());
|
||||
}
|
||||
|
||||
#[test]
|
||||
fn test_get_int() {
|
||||
let mut buf = &b"\xd6zomg"[..];
|
||||
assert_eq!(-42, buf.get_int(1));
|
||||
let mut buf = &b"\xd6zomg"[..];
|
||||
assert_eq!(-42, buf.get_int_le(1));
|
||||
|
||||
let mut buf = &b"\xfe\x1d\xc0zomg"[..];
|
||||
assert_eq!(0xffffffffffc01dfeu64 as i64, buf.get_int_le(3));
|
||||
let mut buf = &b"\xfe\x1d\xc0zomg"[..];
|
||||
assert_eq!(0xfffffffffffe1dc0u64 as i64, buf.get_int(3));
|
||||
}
|
||||
|
||||
#[test]
|
||||
#[should_panic]
|
||||
fn test_get_u16_buffer_underflow() {
|
||||
@@ -66,7 +53,7 @@ fn test_bufs_vec() {
|
||||
|
||||
let mut dst = [IoSlice::new(b1), IoSlice::new(b2)];
|
||||
|
||||
assert_eq!(1, buf.chunks_vectored(&mut dst[..]));
|
||||
assert_eq!(1, buf.bytes_vectored(&mut dst[..]));
|
||||
}
|
||||
|
||||
#[test]
|
||||
@@ -76,16 +63,15 @@ fn test_vec_deque() {
|
||||
let mut buffer: VecDeque<u8> = VecDeque::new();
|
||||
buffer.extend(b"hello world");
|
||||
assert_eq!(11, buffer.remaining());
|
||||
assert_eq!(b"hello world", buffer.chunk());
|
||||
assert_eq!(b"hello world", buffer.bytes());
|
||||
buffer.advance(6);
|
||||
assert_eq!(b"world", buffer.chunk());
|
||||
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[..]);
|
||||
}
|
||||
|
||||
#[allow(unused_allocation)] // This is intentional.
|
||||
#[test]
|
||||
fn test_deref_buf_forwards() {
|
||||
struct Special;
|
||||
@@ -95,8 +81,8 @@ fn test_deref_buf_forwards() {
|
||||
unreachable!("remaining");
|
||||
}
|
||||
|
||||
fn chunk(&self) -> &[u8] {
|
||||
unreachable!("chunk");
|
||||
fn bytes(&self) -> &[u8] {
|
||||
unreachable!("bytes");
|
||||
}
|
||||
|
||||
fn advance(&mut self, _: usize) {
|
||||
|
||||
+10
-157
@@ -3,22 +3,21 @@
|
||||
use bytes::buf::UninitSlice;
|
||||
use bytes::{BufMut, BytesMut};
|
||||
use core::fmt::Write;
|
||||
use core::mem::MaybeUninit;
|
||||
use core::usize;
|
||||
|
||||
#[test]
|
||||
fn test_vec_as_mut_buf() {
|
||||
let mut buf = Vec::with_capacity(64);
|
||||
|
||||
assert_eq!(buf.remaining_mut(), isize::MAX as usize);
|
||||
assert_eq!(buf.remaining_mut(), usize::MAX);
|
||||
|
||||
assert!(buf.chunk_mut().len() >= 64);
|
||||
assert!(buf.bytes_mut().len() >= 64);
|
||||
|
||||
buf.put(&b"zomg"[..]);
|
||||
|
||||
assert_eq!(&buf, b"zomg");
|
||||
|
||||
assert_eq!(buf.remaining_mut(), isize::MAX as usize - 4);
|
||||
assert_eq!(buf.remaining_mut(), usize::MAX - 4);
|
||||
assert_eq!(buf.capacity(), 64);
|
||||
|
||||
for _ in 0..16 {
|
||||
@@ -28,14 +27,6 @@ fn test_vec_as_mut_buf() {
|
||||
assert_eq!(buf.len(), 68);
|
||||
}
|
||||
|
||||
#[test]
|
||||
fn test_vec_put_bytes() {
|
||||
let mut buf = Vec::new();
|
||||
buf.push(17);
|
||||
buf.put_bytes(19, 2);
|
||||
assert_eq!([17, 19, 19], &buf[..]);
|
||||
}
|
||||
|
||||
#[test]
|
||||
fn test_put_u8() {
|
||||
let mut buf = Vec::with_capacity(8);
|
||||
@@ -55,35 +46,7 @@ fn test_put_u16() {
|
||||
}
|
||||
|
||||
#[test]
|
||||
fn test_put_int() {
|
||||
let mut buf = Vec::with_capacity(8);
|
||||
buf.put_int(0x1020304050607080, 3);
|
||||
assert_eq!(b"\x60\x70\x80", &buf[..]);
|
||||
}
|
||||
|
||||
#[test]
|
||||
#[should_panic]
|
||||
fn test_put_int_nbytes_overflow() {
|
||||
let mut buf = Vec::with_capacity(8);
|
||||
buf.put_int(0x1020304050607080, 9);
|
||||
}
|
||||
|
||||
#[test]
|
||||
fn test_put_int_le() {
|
||||
let mut buf = Vec::with_capacity(8);
|
||||
buf.put_int_le(0x1020304050607080, 3);
|
||||
assert_eq!(b"\x80\x70\x60", &buf[..]);
|
||||
}
|
||||
|
||||
#[test]
|
||||
#[should_panic]
|
||||
fn test_put_int_le_nbytes_overflow() {
|
||||
let mut buf = Vec::with_capacity(8);
|
||||
buf.put_int_le(0x1020304050607080, 9);
|
||||
}
|
||||
|
||||
#[test]
|
||||
#[should_panic(expected = "advance out of bounds: the len is 8 but advancing by 12")]
|
||||
#[should_panic(expected = "cannot advance")]
|
||||
fn test_vec_advance_mut() {
|
||||
// Verify fix for #354
|
||||
let mut buf = Vec::with_capacity(8);
|
||||
@@ -102,123 +65,13 @@ fn test_clone() {
|
||||
assert!(buf != buf2);
|
||||
}
|
||||
|
||||
fn do_test_slice_small<T: ?Sized>(make: impl Fn(&mut [u8]) -> &mut T)
|
||||
where
|
||||
for<'r> &'r mut T: BufMut,
|
||||
{
|
||||
let mut buf = [b'X'; 8];
|
||||
|
||||
let mut slice = make(&mut buf[..]);
|
||||
slice.put_bytes(b'A', 2);
|
||||
slice.put_u8(b'B');
|
||||
slice.put_slice(b"BCC");
|
||||
assert_eq!(2, slice.remaining_mut());
|
||||
assert_eq!(b"AABBCCXX", &buf[..]);
|
||||
|
||||
let mut slice = make(&mut buf[..]);
|
||||
slice.put_u32(0x61626364);
|
||||
assert_eq!(4, slice.remaining_mut());
|
||||
assert_eq!(b"abcdCCXX", &buf[..]);
|
||||
|
||||
let mut slice = make(&mut buf[..]);
|
||||
slice.put_u32_le(0x30313233);
|
||||
assert_eq!(4, slice.remaining_mut());
|
||||
assert_eq!(b"3210CCXX", &buf[..]);
|
||||
}
|
||||
|
||||
fn do_test_slice_large<T: ?Sized>(make: impl Fn(&mut [u8]) -> &mut T)
|
||||
where
|
||||
for<'r> &'r mut T: BufMut,
|
||||
{
|
||||
const LEN: usize = 100;
|
||||
const FILL: [u8; LEN] = [b'Y'; LEN];
|
||||
|
||||
let test = |fill: &dyn Fn(&mut &mut T, usize)| {
|
||||
for buf_len in 0..LEN {
|
||||
let mut buf = [b'X'; LEN];
|
||||
for fill_len in 0..=buf_len {
|
||||
let mut slice = make(&mut buf[..buf_len]);
|
||||
fill(&mut slice, fill_len);
|
||||
assert_eq!(buf_len - fill_len, slice.remaining_mut());
|
||||
let (head, tail) = buf.split_at(fill_len);
|
||||
assert_eq!(&FILL[..fill_len], head);
|
||||
assert!(tail.iter().all(|b| *b == b'X'));
|
||||
}
|
||||
}
|
||||
};
|
||||
|
||||
test(&|slice, fill_len| slice.put_slice(&FILL[..fill_len]));
|
||||
test(&|slice, fill_len| slice.put_bytes(FILL[0], fill_len));
|
||||
}
|
||||
|
||||
fn do_test_slice_put_slice_panics<T: ?Sized>(make: impl Fn(&mut [u8]) -> &mut T)
|
||||
where
|
||||
for<'r> &'r mut T: BufMut,
|
||||
{
|
||||
let mut buf = [b'X'; 4];
|
||||
let mut slice = make(&mut buf[..]);
|
||||
slice.put_slice(b"12345");
|
||||
}
|
||||
|
||||
fn do_test_slice_put_bytes_panics<T: ?Sized>(make: impl Fn(&mut [u8]) -> &mut T)
|
||||
where
|
||||
for<'r> &'r mut T: BufMut,
|
||||
{
|
||||
let mut buf = [b'X'; 4];
|
||||
let mut slice = make(&mut buf[..]);
|
||||
slice.put_bytes(b'1', 5);
|
||||
}
|
||||
|
||||
#[test]
|
||||
fn test_slice_buf_mut_small() {
|
||||
do_test_slice_small(|x| x);
|
||||
fn test_mut_slice() {
|
||||
let mut v = vec![0, 0, 0, 0];
|
||||
let mut s = &mut v[..];
|
||||
s.put_u32(42);
|
||||
}
|
||||
|
||||
#[test]
|
||||
fn test_slice_buf_mut_large() {
|
||||
do_test_slice_large(|x| x);
|
||||
}
|
||||
|
||||
#[test]
|
||||
#[should_panic]
|
||||
fn test_slice_buf_mut_put_slice_overflow() {
|
||||
do_test_slice_put_slice_panics(|x| x);
|
||||
}
|
||||
|
||||
#[test]
|
||||
#[should_panic]
|
||||
fn test_slice_buf_mut_put_bytes_overflow() {
|
||||
do_test_slice_put_bytes_panics(|x| x);
|
||||
}
|
||||
|
||||
fn make_maybe_uninit_slice(slice: &mut [u8]) -> &mut [MaybeUninit<u8>] {
|
||||
// SAFETY: [u8] has the same layout as [MaybeUninit<u8>].
|
||||
unsafe { core::mem::transmute(slice) }
|
||||
}
|
||||
|
||||
#[test]
|
||||
fn test_maybe_uninit_buf_mut_small() {
|
||||
do_test_slice_small(make_maybe_uninit_slice);
|
||||
}
|
||||
|
||||
#[test]
|
||||
fn test_maybe_uninit_buf_mut_large() {
|
||||
do_test_slice_large(make_maybe_uninit_slice);
|
||||
}
|
||||
|
||||
#[test]
|
||||
#[should_panic]
|
||||
fn test_maybe_uninit_buf_mut_put_slice_overflow() {
|
||||
do_test_slice_put_slice_panics(make_maybe_uninit_slice);
|
||||
}
|
||||
|
||||
#[test]
|
||||
#[should_panic]
|
||||
fn test_maybe_uninit_buf_mut_put_bytes_overflow() {
|
||||
do_test_slice_put_bytes_panics(make_maybe_uninit_slice);
|
||||
}
|
||||
|
||||
#[allow(unused_allocation)] // This is intentional.
|
||||
#[test]
|
||||
fn test_deref_bufmut_forwards() {
|
||||
struct Special;
|
||||
@@ -228,8 +81,8 @@ fn test_deref_bufmut_forwards() {
|
||||
unreachable!("remaining_mut");
|
||||
}
|
||||
|
||||
fn chunk_mut(&mut self) -> &mut UninitSlice {
|
||||
unreachable!("chunk_mut");
|
||||
fn bytes_mut(&mut self) -> &mut UninitSlice {
|
||||
unreachable!("bytes_mut");
|
||||
}
|
||||
|
||||
unsafe fn advance_mut(&mut self, _: usize) {
|
||||
|
||||
+119
-638
@@ -4,8 +4,8 @@ use bytes::{Buf, BufMut, Bytes, BytesMut};
|
||||
|
||||
use std::usize;
|
||||
|
||||
const LONG: &[u8] = b"mary had a little lamb, little lamb, little lamb";
|
||||
const SHORT: &[u8] = b"hello world";
|
||||
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>() {}
|
||||
@@ -411,8 +411,8 @@ fn freeze_after_split_off() {
|
||||
fn fns_defined_for_bytes_mut() {
|
||||
let mut bytes = BytesMut::from(&b"hello world"[..]);
|
||||
|
||||
let _ = bytes.as_ptr();
|
||||
let _ = bytes.as_mut_ptr();
|
||||
bytes.as_ptr();
|
||||
bytes.as_mut_ptr();
|
||||
|
||||
// Iterator
|
||||
let v: Vec<u8> = bytes.as_ref().iter().cloned().collect();
|
||||
@@ -443,7 +443,7 @@ fn reserve_growth() {
|
||||
let _ = bytes.split();
|
||||
|
||||
bytes.reserve(65);
|
||||
assert_eq!(bytes.capacity(), 117);
|
||||
assert_eq!(bytes.capacity(), 128);
|
||||
}
|
||||
|
||||
#[test]
|
||||
@@ -461,7 +461,6 @@ fn reserve_allocates_at_least_original_capacity() {
|
||||
}
|
||||
|
||||
#[test]
|
||||
#[cfg_attr(miri, ignore)] // Miri is too slow
|
||||
fn reserve_max_original_capacity_value() {
|
||||
const SIZE: usize = 128 * 1024;
|
||||
|
||||
@@ -515,34 +514,6 @@ fn reserve_in_arc_unique_doubles() {
|
||||
assert_eq!(2000, bytes.capacity());
|
||||
}
|
||||
|
||||
#[test]
|
||||
fn reserve_in_arc_unique_does_not_overallocate_after_split() {
|
||||
let mut bytes = BytesMut::from(LONG);
|
||||
let orig_capacity = bytes.capacity();
|
||||
drop(bytes.split_off(LONG.len() / 2));
|
||||
|
||||
// now bytes is Arc and refcount == 1
|
||||
|
||||
let new_capacity = bytes.capacity();
|
||||
bytes.reserve(orig_capacity - new_capacity);
|
||||
assert_eq!(bytes.capacity(), orig_capacity);
|
||||
}
|
||||
|
||||
#[test]
|
||||
fn reserve_in_arc_unique_does_not_overallocate_after_multiple_splits() {
|
||||
let mut bytes = BytesMut::from(LONG);
|
||||
let orig_capacity = bytes.capacity();
|
||||
for _ in 0..10 {
|
||||
drop(bytes.split_off(LONG.len() / 2));
|
||||
|
||||
// now bytes is Arc and refcount == 1
|
||||
|
||||
let new_capacity = bytes.capacity();
|
||||
bytes.reserve(orig_capacity - new_capacity);
|
||||
}
|
||||
assert_eq!(bytes.capacity(), orig_capacity);
|
||||
}
|
||||
|
||||
#[test]
|
||||
fn reserve_in_arc_nonunique_does_not_overallocate() {
|
||||
let mut bytes = BytesMut::with_capacity(1000);
|
||||
@@ -555,25 +526,6 @@ fn reserve_in_arc_nonunique_does_not_overallocate() {
|
||||
assert_eq!(2001, bytes.capacity());
|
||||
}
|
||||
|
||||
/// This function tests `BytesMut::reserve_inner`, where `BytesMut` holds
|
||||
/// a unique reference to the shared vector and decide to reuse it
|
||||
/// by reallocating the `Vec`.
|
||||
#[test]
|
||||
fn reserve_shared_reuse() {
|
||||
let mut bytes = BytesMut::with_capacity(1000);
|
||||
bytes.put_slice(b"Hello, World!");
|
||||
drop(bytes.split());
|
||||
|
||||
bytes.put_slice(b"!123ex123,sadchELLO,_wORLD!");
|
||||
// Use split_off so that v.capacity() - self.cap != off
|
||||
drop(bytes.split_off(9));
|
||||
assert_eq!(&*bytes, b"!123ex123");
|
||||
|
||||
bytes.reserve(2000);
|
||||
assert_eq!(&*bytes, b"!123ex123");
|
||||
assert_eq!(bytes.capacity(), 2009);
|
||||
}
|
||||
|
||||
#[test]
|
||||
fn extend_mut() {
|
||||
let mut bytes = BytesMut::with_capacity(0);
|
||||
@@ -591,35 +543,6 @@ fn extend_from_slice_mut() {
|
||||
}
|
||||
}
|
||||
|
||||
#[test]
|
||||
fn extend_mut_from_bytes() {
|
||||
let mut bytes = BytesMut::with_capacity(0);
|
||||
bytes.extend([Bytes::from(LONG)]);
|
||||
assert_eq!(*bytes, LONG[..]);
|
||||
}
|
||||
|
||||
#[test]
|
||||
fn extend_past_lower_limit_of_size_hint() {
|
||||
// See https://github.com/tokio-rs/bytes/pull/674#pullrequestreview-1913035700
|
||||
struct Iter<I>(I);
|
||||
|
||||
impl<I: Iterator<Item = u8>> Iterator for Iter<I> {
|
||||
type Item = u8;
|
||||
|
||||
fn next(&mut self) -> Option<Self::Item> {
|
||||
self.0.next()
|
||||
}
|
||||
|
||||
fn size_hint(&self) -> (usize, Option<usize>) {
|
||||
(5, None)
|
||||
}
|
||||
}
|
||||
|
||||
let mut bytes = BytesMut::with_capacity(5);
|
||||
bytes.extend(Iter(std::iter::repeat(0).take(10)));
|
||||
assert_eq!(bytes.len(), 10);
|
||||
}
|
||||
|
||||
#[test]
|
||||
fn extend_mut_without_size_hint() {
|
||||
let mut bytes = BytesMut::with_capacity(0);
|
||||
@@ -676,43 +599,6 @@ fn advance_bytes_mut() {
|
||||
assert_eq!(a, b"d zomg wat wat"[..]);
|
||||
}
|
||||
|
||||
// Ensures BytesMut::advance reduces always capacity
|
||||
//
|
||||
// See https://github.com/tokio-rs/bytes/issues/725
|
||||
#[test]
|
||||
fn advance_bytes_mut_remaining_capacity() {
|
||||
// reduce the search space under miri
|
||||
let max_capacity = if cfg!(miri) { 16 } else { 256 };
|
||||
for capacity in 0..=max_capacity {
|
||||
for len in 0..=capacity {
|
||||
for advance in 0..=len {
|
||||
eprintln!("testing capacity={capacity}, len={len}, advance={advance}");
|
||||
let mut buf = BytesMut::with_capacity(capacity);
|
||||
|
||||
buf.resize(len, 42);
|
||||
assert_eq!(buf.len(), len, "resize should write `len` bytes");
|
||||
assert_eq!(
|
||||
buf.remaining(),
|
||||
len,
|
||||
"Buf::remaining() should equal BytesMut::len"
|
||||
);
|
||||
|
||||
buf.advance(advance);
|
||||
assert_eq!(
|
||||
buf.remaining(),
|
||||
len - advance,
|
||||
"Buf::advance should reduce the remaining len"
|
||||
);
|
||||
assert_eq!(
|
||||
buf.capacity(),
|
||||
capacity - advance,
|
||||
"Buf::advance should reduce the remaining capacity"
|
||||
);
|
||||
}
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
#[test]
|
||||
#[should_panic]
|
||||
fn advance_past_len() {
|
||||
@@ -722,15 +608,15 @@ fn advance_past_len() {
|
||||
|
||||
#[test]
|
||||
// Only run these tests on little endian systems. CI uses qemu for testing
|
||||
// big endian... and qemu doesn't really support threading all that well.
|
||||
#[cfg(any(miri, target_endian = "little"))]
|
||||
// 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 = if cfg!(miri) { 100 } else { 1_000 };
|
||||
const ITERS: usize = 1_000;
|
||||
|
||||
for i in 0..ITERS {
|
||||
let data = [i as u8; 256];
|
||||
@@ -769,8 +655,99 @@ fn partial_eq_bytesmut() {
|
||||
assert!(bytesmut != bytes2);
|
||||
}
|
||||
|
||||
/*
|
||||
#[test]
|
||||
fn bytes_mut_unsplit_basic() {
|
||||
fn bytes_join_basic() {
|
||||
let buf = Bytes::from(&b"aaabbbcccddd"[..]);
|
||||
|
||||
let splitted = buf.split_off(6);
|
||||
assert_eq!(b"aaabbb", &buf[..]);
|
||||
assert_eq!(b"cccddd", &splitted[..]);
|
||||
|
||||
buf.join(splitted);
|
||||
assert_eq!(b"aaabbbcccddd", &buf[..]);
|
||||
}
|
||||
|
||||
#[test]
|
||||
fn bytes_join_empty_other() {
|
||||
let buf = Bytes::from(&b"aaabbbcccddd"[..]);
|
||||
|
||||
// empty other
|
||||
let other = Bytes::new();
|
||||
|
||||
buf.join(other);
|
||||
assert_eq!(b"aaabbbcccddd", &buf[..]);
|
||||
}
|
||||
|
||||
#[test]
|
||||
fn bytes_join_empty_self() {
|
||||
// empty self
|
||||
let mut buf = Bytes::new();
|
||||
|
||||
let mut other = Bytes::with_capacity(64);
|
||||
other.extend_from_slice(b"aaabbbcccddd");
|
||||
|
||||
buf.join(other);
|
||||
assert_eq!(b"aaabbbcccddd", &buf[..]);
|
||||
}
|
||||
|
||||
#[test]
|
||||
fn bytes_join_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.join(buf2);
|
||||
assert_eq!(b"aaaabbbbccccdddd", &buf[..]);
|
||||
}
|
||||
|
||||
#[test]
|
||||
fn bytes_join_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.join(buf3);
|
||||
assert_eq!(b"aaaabbbbccccdddd", &buf[..]);
|
||||
}
|
||||
|
||||
#[test]
|
||||
fn bytes_join_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.join(buf3);
|
||||
buf.join(buf2);
|
||||
assert_eq!(b"aaaabbbbccccdddd", &buf[..]);
|
||||
}
|
||||
|
||||
#[test]
|
||||
fn bytes_join_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.join(buf1020);
|
||||
assert_eq!(b"abcdefghijklmnopqrst", &buf0010[..]);
|
||||
assert_eq!(b"fghijklmno", &buf0515[..]);
|
||||
}
|
||||
*/
|
||||
|
||||
#[test]
|
||||
fn bytes_mut_join_basic() {
|
||||
let mut buf = BytesMut::with_capacity(64);
|
||||
buf.extend_from_slice(b"aaabbbcccddd");
|
||||
|
||||
@@ -778,61 +755,36 @@ fn bytes_mut_unsplit_basic() {
|
||||
assert_eq!(b"aaabbb", &buf[..]);
|
||||
assert_eq!(b"cccddd", &splitted[..]);
|
||||
|
||||
buf.unsplit(splitted);
|
||||
buf.join(splitted);
|
||||
assert_eq!(b"aaabbbcccddd", &buf[..]);
|
||||
}
|
||||
|
||||
#[test]
|
||||
fn bytes_mut_unsplit_empty_other() {
|
||||
fn bytes_mut_join_empty_other() {
|
||||
let mut buf = BytesMut::with_capacity(64);
|
||||
buf.extend_from_slice(b"aaabbbcccddd");
|
||||
|
||||
// empty other
|
||||
let other = BytesMut::new();
|
||||
|
||||
buf.unsplit(other);
|
||||
buf.join(other);
|
||||
assert_eq!(b"aaabbbcccddd", &buf[..]);
|
||||
}
|
||||
|
||||
#[test]
|
||||
fn bytes_mut_unsplit_empty_self() {
|
||||
fn bytes_mut_join_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);
|
||||
buf.join(other);
|
||||
assert_eq!(b"aaabbbcccddd", &buf[..]);
|
||||
}
|
||||
|
||||
#[test]
|
||||
fn bytes_mut_unsplit_other_keeps_capacity() {
|
||||
let mut buf = BytesMut::with_capacity(64);
|
||||
buf.extend_from_slice(b"aabb");
|
||||
|
||||
// non empty other created "from" buf
|
||||
let mut other = buf.split_off(buf.len());
|
||||
other.extend_from_slice(b"ccddee");
|
||||
buf.unsplit(other);
|
||||
|
||||
assert_eq!(buf.capacity(), 64);
|
||||
}
|
||||
|
||||
#[test]
|
||||
fn bytes_mut_unsplit_empty_other_keeps_capacity() {
|
||||
let mut buf = BytesMut::with_capacity(64);
|
||||
buf.extend_from_slice(b"aabbccddee");
|
||||
|
||||
// empty other created "from" buf
|
||||
let other = buf.split_off(buf.len());
|
||||
buf.unsplit(other);
|
||||
|
||||
assert_eq!(buf.capacity(), 64);
|
||||
}
|
||||
|
||||
#[test]
|
||||
fn bytes_mut_unsplit_arc_different() {
|
||||
fn bytes_mut_join_arc_different() {
|
||||
let mut buf = BytesMut::with_capacity(64);
|
||||
buf.extend_from_slice(b"aaaabbbbeeee");
|
||||
|
||||
@@ -843,12 +795,12 @@ fn bytes_mut_unsplit_arc_different() {
|
||||
|
||||
let _ = buf2.split_off(8); //arc
|
||||
|
||||
buf.unsplit(buf2);
|
||||
buf.join(buf2);
|
||||
assert_eq!(b"aaaabbbbccccdddd", &buf[..]);
|
||||
}
|
||||
|
||||
#[test]
|
||||
fn bytes_mut_unsplit_arc_non_contiguous() {
|
||||
fn bytes_mut_join_arc_non_contiguous() {
|
||||
let mut buf = BytesMut::with_capacity(64);
|
||||
buf.extend_from_slice(b"aaaabbbbeeeeccccdddd");
|
||||
|
||||
@@ -856,20 +808,20 @@ fn bytes_mut_unsplit_arc_non_contiguous() {
|
||||
|
||||
let buf3 = buf2.split_off(4); //arc
|
||||
|
||||
buf.unsplit(buf3);
|
||||
buf.join(buf3);
|
||||
assert_eq!(b"aaaabbbbccccdddd", &buf[..]);
|
||||
}
|
||||
|
||||
#[test]
|
||||
fn bytes_mut_unsplit_two_split_offs() {
|
||||
fn bytes_mut_join_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);
|
||||
buf2.join(buf3);
|
||||
buf.join(buf2);
|
||||
assert_eq!(b"aaaabbbbccccdddd", &buf[..]);
|
||||
}
|
||||
|
||||
@@ -896,7 +848,7 @@ fn from_iter_no_size_hint() {
|
||||
|
||||
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);
|
||||
let sub = bytes.slice_ref(&slice);
|
||||
assert_eq!(&sub[..], expected);
|
||||
}
|
||||
|
||||
@@ -916,7 +868,7 @@ fn slice_ref_empty() {
|
||||
let bytes = Bytes::from(&b""[..]);
|
||||
let slice = &(bytes.as_ref()[0..0]);
|
||||
|
||||
let sub = bytes.slice_ref(slice);
|
||||
let sub = bytes.slice_ref(&slice);
|
||||
assert_eq!(&sub[..], b"");
|
||||
}
|
||||
|
||||
@@ -960,20 +912,20 @@ fn bytes_buf_mut_advance() {
|
||||
let mut bytes = BytesMut::with_capacity(1024);
|
||||
|
||||
unsafe {
|
||||
let ptr = bytes.chunk_mut().as_mut_ptr();
|
||||
assert_eq!(1024, bytes.chunk_mut().len());
|
||||
let ptr = bytes.bytes_mut().as_mut_ptr();
|
||||
assert_eq!(1024, bytes.bytes_mut().len());
|
||||
|
||||
bytes.advance_mut(10);
|
||||
|
||||
let next = bytes.chunk_mut().as_mut_ptr();
|
||||
assert_eq!(1024 - 10, bytes.chunk_mut().len());
|
||||
let next = bytes.bytes_mut().as_mut_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.chunk_mut().len());
|
||||
assert_eq!(1024, bytes.bytes_mut().len());
|
||||
}
|
||||
}
|
||||
|
||||
@@ -1008,474 +960,3 @@ fn bytes_with_capacity_but_empty() {
|
||||
let vec = Vec::with_capacity(1);
|
||||
let _ = Bytes::from(vec);
|
||||
}
|
||||
|
||||
#[test]
|
||||
fn bytes_put_bytes() {
|
||||
let mut bytes = BytesMut::new();
|
||||
bytes.put_u8(17);
|
||||
bytes.put_bytes(19, 2);
|
||||
assert_eq!([17, 19, 19], bytes.as_ref());
|
||||
}
|
||||
|
||||
#[test]
|
||||
fn box_slice_empty() {
|
||||
// See https://github.com/tokio-rs/bytes/issues/340
|
||||
let empty: Box<[u8]> = Default::default();
|
||||
let b = Bytes::from(empty);
|
||||
assert!(b.is_empty());
|
||||
}
|
||||
|
||||
#[test]
|
||||
fn bytes_into_vec() {
|
||||
// Test kind == KIND_VEC
|
||||
let content = b"helloworld";
|
||||
|
||||
let mut bytes = BytesMut::new();
|
||||
bytes.put_slice(content);
|
||||
|
||||
let vec: Vec<u8> = bytes.into();
|
||||
assert_eq!(&vec, content);
|
||||
|
||||
// Test kind == KIND_ARC, shared.is_unique() == True
|
||||
let mut bytes = BytesMut::new();
|
||||
bytes.put_slice(b"abcdewe23");
|
||||
bytes.put_slice(content);
|
||||
|
||||
// Overwrite the bytes to make sure only one reference to the underlying
|
||||
// Vec exists.
|
||||
bytes = bytes.split_off(9);
|
||||
|
||||
let vec: Vec<u8> = bytes.into();
|
||||
assert_eq!(&vec, content);
|
||||
|
||||
// Test kind == KIND_ARC, shared.is_unique() == False
|
||||
let prefix = b"abcdewe23";
|
||||
|
||||
let mut bytes = BytesMut::new();
|
||||
bytes.put_slice(prefix);
|
||||
bytes.put_slice(content);
|
||||
|
||||
let vec: Vec<u8> = bytes.split_off(prefix.len()).into();
|
||||
assert_eq!(&vec, content);
|
||||
|
||||
let vec: Vec<u8> = bytes.into();
|
||||
assert_eq!(&vec, prefix);
|
||||
}
|
||||
|
||||
#[test]
|
||||
fn test_bytes_into_vec() {
|
||||
// Test STATIC_VTABLE.to_vec
|
||||
let bs = b"1b23exfcz3r";
|
||||
let vec: Vec<u8> = Bytes::from_static(bs).into();
|
||||
assert_eq!(&*vec, bs);
|
||||
|
||||
// Test bytes_mut.SHARED_VTABLE.to_vec impl
|
||||
eprintln!("1");
|
||||
let mut bytes_mut: BytesMut = bs[..].into();
|
||||
|
||||
// Set kind to KIND_ARC so that after freeze, Bytes will use bytes_mut.SHARED_VTABLE
|
||||
eprintln!("2");
|
||||
drop(bytes_mut.split_off(bs.len()));
|
||||
|
||||
eprintln!("3");
|
||||
let b1 = bytes_mut.freeze();
|
||||
eprintln!("4");
|
||||
let b2 = b1.clone();
|
||||
|
||||
eprintln!("{:#?}", (&*b1).as_ptr());
|
||||
|
||||
// shared.is_unique() = False
|
||||
eprintln!("5");
|
||||
assert_eq!(&*Vec::from(b2), bs);
|
||||
|
||||
// shared.is_unique() = True
|
||||
eprintln!("6");
|
||||
assert_eq!(&*Vec::from(b1), bs);
|
||||
|
||||
// Test bytes_mut.SHARED_VTABLE.to_vec impl where offset != 0
|
||||
let mut bytes_mut1: BytesMut = bs[..].into();
|
||||
let bytes_mut2 = bytes_mut1.split_off(9);
|
||||
|
||||
let b1 = bytes_mut1.freeze();
|
||||
let b2 = bytes_mut2.freeze();
|
||||
|
||||
assert_eq!(Vec::from(b2), bs[9..]);
|
||||
assert_eq!(Vec::from(b1), bs[..9]);
|
||||
}
|
||||
|
||||
#[test]
|
||||
fn test_bytes_into_vec_promotable_even() {
|
||||
let vec = vec![33u8; 1024];
|
||||
|
||||
// Test cases where kind == KIND_VEC
|
||||
let b1 = Bytes::from(vec.clone());
|
||||
assert_eq!(Vec::from(b1), vec);
|
||||
|
||||
// Test cases where kind == KIND_ARC, ref_cnt == 1
|
||||
let b1 = Bytes::from(vec.clone());
|
||||
drop(b1.clone());
|
||||
assert_eq!(Vec::from(b1), vec);
|
||||
|
||||
// Test cases where kind == KIND_ARC, ref_cnt == 2
|
||||
let b1 = Bytes::from(vec.clone());
|
||||
let b2 = b1.clone();
|
||||
assert_eq!(Vec::from(b1), vec);
|
||||
|
||||
// Test cases where vtable = SHARED_VTABLE, kind == KIND_ARC, ref_cnt == 1
|
||||
assert_eq!(Vec::from(b2), vec);
|
||||
|
||||
// Test cases where offset != 0
|
||||
let mut b1 = Bytes::from(vec.clone());
|
||||
let b2 = b1.split_off(20);
|
||||
|
||||
assert_eq!(Vec::from(b2), vec[20..]);
|
||||
assert_eq!(Vec::from(b1), vec[..20]);
|
||||
}
|
||||
|
||||
#[test]
|
||||
fn test_bytes_vec_conversion() {
|
||||
let mut vec = Vec::with_capacity(10);
|
||||
vec.extend(b"abcdefg");
|
||||
let b = Bytes::from(vec);
|
||||
let v = Vec::from(b);
|
||||
assert_eq!(v.len(), 7);
|
||||
assert_eq!(v.capacity(), 10);
|
||||
|
||||
let mut b = Bytes::from(v);
|
||||
b.advance(1);
|
||||
let v = Vec::from(b);
|
||||
assert_eq!(v.len(), 6);
|
||||
assert_eq!(v.capacity(), 10);
|
||||
assert_eq!(v.as_slice(), b"bcdefg");
|
||||
}
|
||||
|
||||
#[test]
|
||||
fn test_bytes_mut_conversion() {
|
||||
let mut b1 = BytesMut::with_capacity(10);
|
||||
b1.extend(b"abcdefg");
|
||||
let b2 = Bytes::from(b1);
|
||||
let v = Vec::from(b2);
|
||||
assert_eq!(v.len(), 7);
|
||||
assert_eq!(v.capacity(), 10);
|
||||
|
||||
let mut b = Bytes::from(v);
|
||||
b.advance(1);
|
||||
let v = Vec::from(b);
|
||||
assert_eq!(v.len(), 6);
|
||||
assert_eq!(v.capacity(), 10);
|
||||
assert_eq!(v.as_slice(), b"bcdefg");
|
||||
}
|
||||
|
||||
#[test]
|
||||
fn test_bytes_capacity_len() {
|
||||
for cap in 0..100 {
|
||||
for len in 0..=cap {
|
||||
let mut v = Vec::with_capacity(cap);
|
||||
v.resize(len, 0);
|
||||
let _ = Bytes::from(v);
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
#[test]
|
||||
fn static_is_unique() {
|
||||
let b = Bytes::from_static(LONG);
|
||||
assert!(!b.is_unique());
|
||||
}
|
||||
|
||||
#[test]
|
||||
fn vec_is_unique() {
|
||||
let v: Vec<u8> = LONG.to_vec();
|
||||
let b = Bytes::from(v);
|
||||
assert!(b.is_unique());
|
||||
}
|
||||
|
||||
#[test]
|
||||
fn arc_is_unique() {
|
||||
let v: Vec<u8> = LONG.to_vec();
|
||||
let b = Bytes::from(v);
|
||||
let c = b.clone();
|
||||
assert!(!b.is_unique());
|
||||
drop(c);
|
||||
assert!(b.is_unique());
|
||||
}
|
||||
|
||||
#[test]
|
||||
fn shared_is_unique() {
|
||||
let v: Vec<u8> = LONG.to_vec();
|
||||
let b = Bytes::from(v);
|
||||
let c = b.clone();
|
||||
assert!(!c.is_unique());
|
||||
drop(b);
|
||||
assert!(c.is_unique());
|
||||
}
|
||||
|
||||
#[test]
|
||||
fn mut_shared_is_unique() {
|
||||
let mut b = BytesMut::from(LONG);
|
||||
let c = b.split().freeze();
|
||||
assert!(!c.is_unique());
|
||||
drop(b);
|
||||
assert!(c.is_unique());
|
||||
}
|
||||
|
||||
#[test]
|
||||
fn test_bytesmut_from_bytes_static() {
|
||||
let bs = b"1b23exfcz3r";
|
||||
|
||||
// Test STATIC_VTABLE.to_mut
|
||||
let bytes_mut = BytesMut::from(Bytes::from_static(bs));
|
||||
assert_eq!(bytes_mut, bs[..]);
|
||||
}
|
||||
|
||||
#[test]
|
||||
fn test_bytesmut_from_bytes_bytes_mut_vec() {
|
||||
let bs = b"1b23exfcz3r";
|
||||
let bs_long = b"1b23exfcz3r1b23exfcz3r";
|
||||
|
||||
// Test case where kind == KIND_VEC
|
||||
let mut bytes_mut: BytesMut = bs[..].into();
|
||||
bytes_mut = BytesMut::from(bytes_mut.freeze());
|
||||
assert_eq!(bytes_mut, bs[..]);
|
||||
bytes_mut.extend_from_slice(&bs[..]);
|
||||
assert_eq!(bytes_mut, bs_long[..]);
|
||||
}
|
||||
|
||||
#[test]
|
||||
fn test_bytesmut_from_bytes_bytes_mut_shared() {
|
||||
let bs = b"1b23exfcz3r";
|
||||
|
||||
// Set kind to KIND_ARC so that after freeze, Bytes will use bytes_mut.SHARED_VTABLE
|
||||
let mut bytes_mut: BytesMut = bs[..].into();
|
||||
drop(bytes_mut.split_off(bs.len()));
|
||||
|
||||
let b1 = bytes_mut.freeze();
|
||||
let b2 = b1.clone();
|
||||
|
||||
// shared.is_unique() = False
|
||||
let mut b1m = BytesMut::from(b1);
|
||||
assert_eq!(b1m, bs[..]);
|
||||
b1m[0] = b'9';
|
||||
|
||||
// shared.is_unique() = True
|
||||
let b2m = BytesMut::from(b2);
|
||||
assert_eq!(b2m, bs[..]);
|
||||
}
|
||||
|
||||
#[test]
|
||||
fn test_bytesmut_from_bytes_bytes_mut_offset() {
|
||||
let bs = b"1b23exfcz3r";
|
||||
|
||||
// Test bytes_mut.SHARED_VTABLE.to_mut impl where offset != 0
|
||||
let mut bytes_mut1: BytesMut = bs[..].into();
|
||||
let bytes_mut2 = bytes_mut1.split_off(9);
|
||||
|
||||
let b1 = bytes_mut1.freeze();
|
||||
let b2 = bytes_mut2.freeze();
|
||||
|
||||
let b1m = BytesMut::from(b1);
|
||||
let b2m = BytesMut::from(b2);
|
||||
|
||||
assert_eq!(b2m, bs[9..]);
|
||||
assert_eq!(b1m, bs[..9]);
|
||||
}
|
||||
|
||||
#[test]
|
||||
fn test_bytesmut_from_bytes_promotable_even_vec() {
|
||||
let vec = vec![33u8; 1024];
|
||||
|
||||
// Test case where kind == KIND_VEC
|
||||
let b1 = Bytes::from(vec.clone());
|
||||
let b1m = BytesMut::from(b1);
|
||||
assert_eq!(b1m, vec);
|
||||
}
|
||||
|
||||
#[test]
|
||||
fn test_bytesmut_from_bytes_promotable_even_arc_1() {
|
||||
let vec = vec![33u8; 1024];
|
||||
|
||||
// Test case where kind == KIND_ARC, ref_cnt == 1
|
||||
let b1 = Bytes::from(vec.clone());
|
||||
drop(b1.clone());
|
||||
let b1m = BytesMut::from(b1);
|
||||
assert_eq!(b1m, vec);
|
||||
}
|
||||
|
||||
#[test]
|
||||
fn test_bytesmut_from_bytes_promotable_even_arc_2() {
|
||||
let vec = vec![33u8; 1024];
|
||||
|
||||
// Test case where kind == KIND_ARC, ref_cnt == 2
|
||||
let b1 = Bytes::from(vec.clone());
|
||||
let b2 = b1.clone();
|
||||
let b1m = BytesMut::from(b1);
|
||||
assert_eq!(b1m, vec);
|
||||
|
||||
// Test case where vtable = SHARED_VTABLE, kind == KIND_ARC, ref_cnt == 1
|
||||
let b2m = BytesMut::from(b2);
|
||||
assert_eq!(b2m, vec);
|
||||
}
|
||||
|
||||
#[test]
|
||||
fn test_bytesmut_from_bytes_promotable_even_arc_offset() {
|
||||
let vec = vec![33u8; 1024];
|
||||
|
||||
// Test case where offset != 0
|
||||
let mut b1 = Bytes::from(vec.clone());
|
||||
let b2 = b1.split_off(20);
|
||||
let b1m = BytesMut::from(b1);
|
||||
let b2m = BytesMut::from(b2);
|
||||
|
||||
assert_eq!(b2m, vec[20..]);
|
||||
assert_eq!(b1m, vec[..20]);
|
||||
}
|
||||
|
||||
#[test]
|
||||
fn try_reclaim_empty() {
|
||||
let mut buf = BytesMut::new();
|
||||
assert_eq!(false, buf.try_reclaim(6));
|
||||
buf.reserve(6);
|
||||
assert_eq!(true, buf.try_reclaim(6));
|
||||
let cap = buf.capacity();
|
||||
assert!(cap >= 6);
|
||||
assert_eq!(false, buf.try_reclaim(cap + 1));
|
||||
|
||||
let mut buf = BytesMut::new();
|
||||
buf.reserve(6);
|
||||
let cap = buf.capacity();
|
||||
assert!(cap >= 6);
|
||||
let mut split = buf.split();
|
||||
drop(buf);
|
||||
assert_eq!(0, split.capacity());
|
||||
assert_eq!(true, split.try_reclaim(6));
|
||||
assert_eq!(false, split.try_reclaim(cap + 1));
|
||||
}
|
||||
|
||||
#[test]
|
||||
fn try_reclaim_vec() {
|
||||
let mut buf = BytesMut::with_capacity(6);
|
||||
buf.put_slice(b"abc");
|
||||
// Reclaiming a ludicrous amount of space should calmly return false
|
||||
assert_eq!(false, buf.try_reclaim(usize::MAX));
|
||||
|
||||
assert_eq!(false, buf.try_reclaim(6));
|
||||
buf.advance(2);
|
||||
assert_eq!(4, buf.capacity());
|
||||
// We can reclaim 5 bytes, because the byte in the buffer can be moved to the front. 6 bytes
|
||||
// cannot be reclaimed because there is already one byte stored
|
||||
assert_eq!(false, buf.try_reclaim(6));
|
||||
assert_eq!(true, buf.try_reclaim(5));
|
||||
buf.advance(1);
|
||||
assert_eq!(true, buf.try_reclaim(6));
|
||||
assert_eq!(6, buf.capacity());
|
||||
}
|
||||
|
||||
#[test]
|
||||
fn try_reclaim_arc() {
|
||||
let mut buf = BytesMut::with_capacity(6);
|
||||
buf.put_slice(b"abc");
|
||||
let x = buf.split().freeze();
|
||||
buf.put_slice(b"def");
|
||||
// Reclaiming a ludicrous amount of space should calmly return false
|
||||
assert_eq!(false, buf.try_reclaim(usize::MAX));
|
||||
|
||||
let y = buf.split().freeze();
|
||||
let z = y.clone();
|
||||
assert_eq!(false, buf.try_reclaim(6));
|
||||
drop(x);
|
||||
drop(z);
|
||||
assert_eq!(false, buf.try_reclaim(6));
|
||||
drop(y);
|
||||
assert_eq!(true, buf.try_reclaim(6));
|
||||
assert_eq!(6, buf.capacity());
|
||||
assert_eq!(0, buf.len());
|
||||
buf.put_slice(b"abc");
|
||||
buf.put_slice(b"def");
|
||||
assert_eq!(6, buf.capacity());
|
||||
assert_eq!(6, buf.len());
|
||||
assert_eq!(false, buf.try_reclaim(6));
|
||||
buf.advance(4);
|
||||
assert_eq!(true, buf.try_reclaim(4));
|
||||
buf.advance(2);
|
||||
assert_eq!(true, buf.try_reclaim(6));
|
||||
}
|
||||
|
||||
#[test]
|
||||
fn split_off_empty_addr() {
|
||||
let mut buf = Bytes::from(vec![0; 1024]);
|
||||
|
||||
let ptr_start = buf.as_ptr();
|
||||
let ptr_end = ptr_start.wrapping_add(1024);
|
||||
|
||||
let empty_end = buf.split_off(1024);
|
||||
assert_eq!(empty_end.len(), 0);
|
||||
assert_eq!(empty_end.as_ptr(), ptr_end);
|
||||
|
||||
let _ = buf.split_off(0);
|
||||
assert_eq!(buf.len(), 0);
|
||||
assert_eq!(buf.as_ptr(), ptr_start);
|
||||
|
||||
// Is miri happy about the provenance?
|
||||
let _ = &empty_end[..];
|
||||
let _ = &buf[..];
|
||||
}
|
||||
|
||||
#[test]
|
||||
fn split_to_empty_addr() {
|
||||
let mut buf = Bytes::from(vec![0; 1024]);
|
||||
|
||||
let ptr_start = buf.as_ptr();
|
||||
let ptr_end = ptr_start.wrapping_add(1024);
|
||||
|
||||
let empty_start = buf.split_to(0);
|
||||
assert_eq!(empty_start.len(), 0);
|
||||
assert_eq!(empty_start.as_ptr(), ptr_start);
|
||||
|
||||
let _ = buf.split_to(1024);
|
||||
assert_eq!(buf.len(), 0);
|
||||
assert_eq!(buf.as_ptr(), ptr_end);
|
||||
|
||||
// Is miri happy about the provenance?
|
||||
let _ = &empty_start[..];
|
||||
let _ = &buf[..];
|
||||
}
|
||||
|
||||
#[test]
|
||||
fn split_off_empty_addr_mut() {
|
||||
let mut buf = BytesMut::from([0; 1024].as_slice());
|
||||
|
||||
let ptr_start = buf.as_ptr();
|
||||
let ptr_end = ptr_start.wrapping_add(1024);
|
||||
|
||||
let empty_end = buf.split_off(1024);
|
||||
assert_eq!(empty_end.len(), 0);
|
||||
assert_eq!(empty_end.as_ptr(), ptr_end);
|
||||
|
||||
let _ = buf.split_off(0);
|
||||
assert_eq!(buf.len(), 0);
|
||||
assert_eq!(buf.as_ptr(), ptr_start);
|
||||
|
||||
// Is miri happy about the provenance?
|
||||
let _ = &empty_end[..];
|
||||
let _ = &buf[..];
|
||||
}
|
||||
|
||||
#[test]
|
||||
fn split_to_empty_addr_mut() {
|
||||
let mut buf = BytesMut::from([0; 1024].as_slice());
|
||||
|
||||
let ptr_start = buf.as_ptr();
|
||||
let ptr_end = ptr_start.wrapping_add(1024);
|
||||
|
||||
let empty_start = buf.split_to(0);
|
||||
assert_eq!(empty_start.len(), 0);
|
||||
assert_eq!(empty_start.as_ptr(), ptr_start);
|
||||
|
||||
let _ = buf.split_to(1024);
|
||||
assert_eq!(buf.len(), 0);
|
||||
assert_eq!(buf.as_ptr(), ptr_end);
|
||||
|
||||
// Is miri happy about the provenance?
|
||||
let _ = &empty_start[..];
|
||||
let _ = &buf[..];
|
||||
}
|
||||
|
||||
@@ -1,12 +1,10 @@
|
||||
//! Test using `Bytes` with an allocator that hands out "odd" pointers for
|
||||
//! vectors (pointers where the LSB is set).
|
||||
|
||||
#![cfg(not(miri))] // Miri does not support custom allocators (also, Miri is "odd" by default with 50% chance)
|
||||
|
||||
use std::alloc::{GlobalAlloc, Layout, System};
|
||||
use std::ptr;
|
||||
|
||||
use bytes::{Bytes, BytesMut};
|
||||
use bytes::Bytes;
|
||||
|
||||
#[global_allocator]
|
||||
static ODD: Odd = Odd;
|
||||
@@ -24,7 +22,8 @@ unsafe impl GlobalAlloc for Odd {
|
||||
};
|
||||
let ptr = System.alloc(new_layout);
|
||||
if !ptr.is_null() {
|
||||
ptr.offset(1)
|
||||
let ptr = ptr.offset(1);
|
||||
ptr
|
||||
} else {
|
||||
ptr
|
||||
}
|
||||
@@ -66,82 +65,3 @@ fn test_bytes_clone_drop() {
|
||||
let b1 = Bytes::from(vec);
|
||||
let _b2 = b1.clone();
|
||||
}
|
||||
|
||||
#[test]
|
||||
fn test_bytes_into_vec() {
|
||||
let vec = vec![33u8; 1024];
|
||||
|
||||
// Test cases where kind == KIND_VEC
|
||||
let b1 = Bytes::from(vec.clone());
|
||||
assert_eq!(Vec::from(b1), vec);
|
||||
|
||||
// Test cases where kind == KIND_ARC, ref_cnt == 1
|
||||
let b1 = Bytes::from(vec.clone());
|
||||
drop(b1.clone());
|
||||
assert_eq!(Vec::from(b1), vec);
|
||||
|
||||
// Test cases where kind == KIND_ARC, ref_cnt == 2
|
||||
let b1 = Bytes::from(vec.clone());
|
||||
let b2 = b1.clone();
|
||||
assert_eq!(Vec::from(b1), vec);
|
||||
|
||||
// Test cases where vtable = SHARED_VTABLE, kind == KIND_ARC, ref_cnt == 1
|
||||
assert_eq!(Vec::from(b2), vec);
|
||||
|
||||
// Test cases where offset != 0
|
||||
let mut b1 = Bytes::from(vec.clone());
|
||||
let b2 = b1.split_off(20);
|
||||
|
||||
assert_eq!(Vec::from(b2), vec[20..]);
|
||||
assert_eq!(Vec::from(b1), vec[..20]);
|
||||
}
|
||||
|
||||
#[test]
|
||||
fn test_bytesmut_from_bytes_vec() {
|
||||
let vec = vec![33u8; 1024];
|
||||
|
||||
// Test case where kind == KIND_VEC
|
||||
let b1 = Bytes::from(vec.clone());
|
||||
let b1m = BytesMut::from(b1);
|
||||
assert_eq!(b1m, vec);
|
||||
}
|
||||
|
||||
#[test]
|
||||
fn test_bytesmut_from_bytes_arc_1() {
|
||||
let vec = vec![33u8; 1024];
|
||||
|
||||
// Test case where kind == KIND_ARC, ref_cnt == 1
|
||||
let b1 = Bytes::from(vec.clone());
|
||||
drop(b1.clone());
|
||||
let b1m = BytesMut::from(b1);
|
||||
assert_eq!(b1m, vec);
|
||||
}
|
||||
|
||||
#[test]
|
||||
fn test_bytesmut_from_bytes_arc_2() {
|
||||
let vec = vec![33u8; 1024];
|
||||
|
||||
// Test case where kind == KIND_ARC, ref_cnt == 2
|
||||
let b1 = Bytes::from(vec.clone());
|
||||
let b2 = b1.clone();
|
||||
let b1m = BytesMut::from(b1);
|
||||
assert_eq!(b1m, vec);
|
||||
|
||||
// Test case where vtable = SHARED_VTABLE, kind == KIND_ARC, ref_cnt == 1
|
||||
let b2m = BytesMut::from(b2);
|
||||
assert_eq!(b2m, vec);
|
||||
}
|
||||
|
||||
#[test]
|
||||
fn test_bytesmut_from_bytes_arc_offset() {
|
||||
let vec = vec![33u8; 1024];
|
||||
|
||||
// Test case where offset != 0
|
||||
let mut b1 = Bytes::from(vec.clone());
|
||||
let b2 = b1.split_off(20);
|
||||
let b1m = BytesMut::from(b1);
|
||||
let b2m = BytesMut::from(b2);
|
||||
|
||||
assert_eq!(b2m, vec[20..]);
|
||||
assert_eq!(b1m, vec[..20]);
|
||||
}
|
||||
|
||||
+39
-103
@@ -1,87 +1,61 @@
|
||||
use std::alloc::{GlobalAlloc, Layout, System};
|
||||
use std::ptr::null_mut;
|
||||
use std::sync::atomic::{AtomicPtr, AtomicUsize, Ordering};
|
||||
use std::{mem, ptr};
|
||||
|
||||
use bytes::{Buf, Bytes};
|
||||
|
||||
#[global_allocator]
|
||||
static LEDGER: Ledger = Ledger::new();
|
||||
static LEDGER: Ledger = Ledger;
|
||||
|
||||
const LEDGER_LENGTH: usize = 2048;
|
||||
struct Ledger;
|
||||
|
||||
struct Ledger {
|
||||
alloc_table: [(AtomicPtr<u8>, AtomicUsize); LEDGER_LENGTH],
|
||||
}
|
||||
|
||||
impl Ledger {
|
||||
const fn new() -> Self {
|
||||
const ELEM: (AtomicPtr<u8>, AtomicUsize) =
|
||||
(AtomicPtr::new(null_mut()), AtomicUsize::new(0));
|
||||
let alloc_table = [ELEM; LEDGER_LENGTH];
|
||||
|
||||
Self { alloc_table }
|
||||
}
|
||||
|
||||
/// Iterate over our table until we find an open entry, then insert into said entry
|
||||
fn insert(&self, ptr: *mut u8, size: usize) {
|
||||
for (entry_ptr, entry_size) in self.alloc_table.iter() {
|
||||
// SeqCst is good enough here, we don't care about perf, i just want to be correct!
|
||||
if entry_ptr
|
||||
.compare_exchange(null_mut(), ptr, Ordering::SeqCst, Ordering::SeqCst)
|
||||
.is_ok()
|
||||
{
|
||||
entry_size.store(size, Ordering::SeqCst);
|
||||
break;
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
fn remove(&self, ptr: *mut u8) -> usize {
|
||||
for (entry_ptr, entry_size) in self.alloc_table.iter() {
|
||||
// set the value to be something that will never try and be deallocated, so that we
|
||||
// don't have any chance of a race condition
|
||||
//
|
||||
// dont worry, LEDGER_LENGTH is really long to compensate for us not reclaiming space
|
||||
if entry_ptr
|
||||
.compare_exchange(
|
||||
ptr,
|
||||
invalid_ptr(usize::MAX),
|
||||
Ordering::SeqCst,
|
||||
Ordering::SeqCst,
|
||||
)
|
||||
.is_ok()
|
||||
{
|
||||
return entry_size.load(Ordering::SeqCst);
|
||||
}
|
||||
}
|
||||
|
||||
panic!("Couldn't find a matching entry for {:x?}", ptr);
|
||||
}
|
||||
}
|
||||
const USIZE_SIZE: usize = mem::size_of::<usize>();
|
||||
|
||||
unsafe impl GlobalAlloc for Ledger {
|
||||
unsafe fn alloc(&self, layout: Layout) -> *mut u8 {
|
||||
let size = layout.size();
|
||||
let ptr = System.alloc(layout);
|
||||
self.insert(ptr, size);
|
||||
ptr
|
||||
if layout.align() == 1 && layout.size() > 0 {
|
||||
// Allocate extra space to stash a record of
|
||||
// how much space there was.
|
||||
let orig_size = layout.size();
|
||||
let size = orig_size + USIZE_SIZE;
|
||||
let new_layout = match Layout::from_size_align(size, 1) {
|
||||
Ok(layout) => layout,
|
||||
Err(_err) => return ptr::null_mut(),
|
||||
};
|
||||
let ptr = System.alloc(new_layout);
|
||||
if !ptr.is_null() {
|
||||
(ptr as *mut usize).write(orig_size);
|
||||
let ptr = ptr.offset(USIZE_SIZE as isize);
|
||||
ptr
|
||||
} else {
|
||||
ptr
|
||||
}
|
||||
} else {
|
||||
System.alloc(layout)
|
||||
}
|
||||
}
|
||||
|
||||
unsafe fn dealloc(&self, ptr: *mut u8, layout: Layout) {
|
||||
let orig_size = self.remove(ptr);
|
||||
if layout.align() == 1 && layout.size() > 0 {
|
||||
let off_ptr = (ptr as *mut usize).offset(-1);
|
||||
let orig_size = off_ptr.read();
|
||||
if orig_size != layout.size() {
|
||||
panic!(
|
||||
"bad dealloc: alloc size was {}, dealloc size is {}",
|
||||
orig_size,
|
||||
layout.size()
|
||||
);
|
||||
}
|
||||
|
||||
if orig_size != layout.size() {
|
||||
panic!(
|
||||
"bad dealloc: alloc size was {}, dealloc size is {}",
|
||||
orig_size,
|
||||
layout.size()
|
||||
);
|
||||
let new_layout = match Layout::from_size_align(layout.size() + USIZE_SIZE, 1) {
|
||||
Ok(layout) => layout,
|
||||
Err(_err) => std::process::abort(),
|
||||
};
|
||||
System.dealloc(off_ptr as *mut u8, new_layout);
|
||||
} else {
|
||||
System.dealloc(ptr, layout);
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
#[test]
|
||||
fn test_bytes_advance() {
|
||||
let mut bytes = Bytes::from(vec![10, 20, 30]);
|
||||
@@ -103,41 +77,3 @@ fn test_bytes_truncate_and_advance() {
|
||||
bytes.advance(1);
|
||||
drop(bytes);
|
||||
}
|
||||
|
||||
/// Returns a dangling pointer with the given address. This is used to store
|
||||
/// integer data in pointer fields.
|
||||
#[inline]
|
||||
fn invalid_ptr<T>(addr: usize) -> *mut T {
|
||||
let ptr = std::ptr::null_mut::<u8>().wrapping_add(addr);
|
||||
debug_assert_eq!(ptr as usize, addr);
|
||||
ptr.cast::<T>()
|
||||
}
|
||||
|
||||
#[test]
|
||||
fn test_bytes_into_vec() {
|
||||
let vec = vec![33u8; 1024];
|
||||
|
||||
// Test cases where kind == KIND_VEC
|
||||
let b1 = Bytes::from(vec.clone());
|
||||
assert_eq!(Vec::from(b1), vec);
|
||||
|
||||
// Test cases where kind == KIND_ARC, ref_cnt == 1
|
||||
let b1 = Bytes::from(vec.clone());
|
||||
drop(b1.clone());
|
||||
assert_eq!(Vec::from(b1), vec);
|
||||
|
||||
// Test cases where kind == KIND_ARC, ref_cnt == 2
|
||||
let b1 = Bytes::from(vec.clone());
|
||||
let b2 = b1.clone();
|
||||
assert_eq!(Vec::from(b1), vec);
|
||||
|
||||
// Test cases where vtable = SHARED_VTABLE, kind == KIND_ARC, ref_cnt == 1
|
||||
assert_eq!(Vec::from(b2), vec);
|
||||
|
||||
// Test cases where offset != 0
|
||||
let mut b1 = Bytes::from(vec.clone());
|
||||
let b2 = b1.split_off(20);
|
||||
|
||||
assert_eq!(Vec::from(b2), vec[20..]);
|
||||
assert_eq!(Vec::from(b1), vec[..20]);
|
||||
}
|
||||
|
||||
+4
-47
@@ -62,7 +62,7 @@ fn vectored_read() {
|
||||
IoSlice::new(b4),
|
||||
];
|
||||
|
||||
assert_eq!(2, buf.chunks_vectored(&mut iovecs));
|
||||
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""[..]);
|
||||
@@ -83,7 +83,7 @@ fn vectored_read() {
|
||||
IoSlice::new(b4),
|
||||
];
|
||||
|
||||
assert_eq!(2, buf.chunks_vectored(&mut iovecs));
|
||||
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""[..]);
|
||||
@@ -104,7 +104,7 @@ fn vectored_read() {
|
||||
IoSlice::new(b4),
|
||||
];
|
||||
|
||||
assert_eq!(1, buf.chunks_vectored(&mut iovecs));
|
||||
assert_eq!(1, buf.bytes_vectored(&mut iovecs));
|
||||
assert_eq!(iovecs[0][..], b"world"[..]);
|
||||
assert_eq!(iovecs[1][..], b""[..]);
|
||||
assert_eq!(iovecs[2][..], b""[..]);
|
||||
@@ -125,53 +125,10 @@ fn vectored_read() {
|
||||
IoSlice::new(b4),
|
||||
];
|
||||
|
||||
assert_eq!(1, buf.chunks_vectored(&mut iovecs));
|
||||
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""[..]);
|
||||
}
|
||||
}
|
||||
|
||||
#[test]
|
||||
fn chain_growing_buffer() {
|
||||
let mut buff = [' ' as u8; 10];
|
||||
let mut vec = b"wassup".to_vec();
|
||||
|
||||
let mut chained = (&mut buff[..]).chain_mut(&mut vec).chain_mut(Vec::new()); // Required for potential overflow because remaining_mut for Vec is isize::MAX - vec.len(), but for chain_mut is usize::MAX
|
||||
|
||||
chained.put_slice(b"hey there123123");
|
||||
|
||||
assert_eq!(&buff, b"hey there1");
|
||||
assert_eq!(&vec, b"wassup23123");
|
||||
}
|
||||
|
||||
#[test]
|
||||
fn chain_overflow_remaining_mut() {
|
||||
let mut chained = Vec::<u8>::new().chain_mut(Vec::new()).chain_mut(Vec::new());
|
||||
|
||||
assert_eq!(chained.remaining_mut(), usize::MAX);
|
||||
chained.put_slice(&[0; 256]);
|
||||
assert_eq!(chained.remaining_mut(), usize::MAX);
|
||||
}
|
||||
|
||||
#[test]
|
||||
fn chain_get_bytes() {
|
||||
let mut ab = Bytes::copy_from_slice(b"ab");
|
||||
let mut cd = Bytes::copy_from_slice(b"cd");
|
||||
let ab_ptr = ab.as_ptr();
|
||||
let cd_ptr = cd.as_ptr();
|
||||
let mut chain = (&mut ab).chain(&mut cd);
|
||||
let a = chain.copy_to_bytes(1);
|
||||
let bc = chain.copy_to_bytes(2);
|
||||
let d = chain.copy_to_bytes(1);
|
||||
|
||||
assert_eq!(Bytes::copy_from_slice(b"a"), a);
|
||||
assert_eq!(Bytes::copy_from_slice(b"bc"), bc);
|
||||
assert_eq!(Bytes::copy_from_slice(b"d"), d);
|
||||
|
||||
// assert `get_bytes` did not allocate
|
||||
assert_eq!(ab_ptr, a.as_ptr());
|
||||
// assert `get_bytes` did not allocate
|
||||
assert_eq!(cd_ptr.wrapping_offset(1), d.as_ptr());
|
||||
}
|
||||
|
||||
+4
-4
@@ -1,11 +1,11 @@
|
||||
#![warn(rust_2018_idioms)]
|
||||
|
||||
use bytes::{buf::IntoIter, Bytes};
|
||||
use bytes::Bytes;
|
||||
|
||||
#[test]
|
||||
fn iter_len() {
|
||||
let buf = Bytes::from_static(b"hello world");
|
||||
let iter = IntoIter::new(buf);
|
||||
let iter = buf.iter();
|
||||
|
||||
assert_eq!(iter.size_hint(), (11, Some(11)));
|
||||
assert_eq!(iter.len(), 11);
|
||||
@@ -13,8 +13,8 @@ fn iter_len() {
|
||||
|
||||
#[test]
|
||||
fn empty_iter_len() {
|
||||
let buf = Bytes::new();
|
||||
let iter = IntoIter::new(buf);
|
||||
let buf = Bytes::from_static(b"");
|
||||
let iter = buf.iter();
|
||||
|
||||
assert_eq!(iter.size_hint(), (0, Some(0)));
|
||||
assert_eq!(iter.len(), 0);
|
||||
|
||||
+1
-21
@@ -1,7 +1,6 @@
|
||||
#![warn(rust_2018_idioms)]
|
||||
|
||||
use bytes::buf::Buf;
|
||||
use bytes::Bytes;
|
||||
|
||||
#[test]
|
||||
fn long_take() {
|
||||
@@ -9,24 +8,5 @@ fn long_take() {
|
||||
// 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.chunk());
|
||||
}
|
||||
|
||||
#[test]
|
||||
fn take_copy_to_bytes() {
|
||||
let mut abcd = Bytes::copy_from_slice(b"abcd");
|
||||
let abcd_ptr = abcd.as_ptr();
|
||||
let mut take = (&mut abcd).take(2);
|
||||
let a = take.copy_to_bytes(1);
|
||||
assert_eq!(Bytes::copy_from_slice(b"a"), a);
|
||||
// assert `to_bytes` did not allocate
|
||||
assert_eq!(abcd_ptr, a.as_ptr());
|
||||
assert_eq!(Bytes::copy_from_slice(b"bcd"), abcd);
|
||||
}
|
||||
|
||||
#[test]
|
||||
#[should_panic]
|
||||
fn take_copy_to_bytes_panics() {
|
||||
let abcd = Bytes::copy_from_slice(b"abcd");
|
||||
abcd.take(2).copy_to_bytes(3);
|
||||
assert_eq!(b"hello world", buf.bytes());
|
||||
}
|
||||
|
||||
Reference in New Issue
Block a user