diff options
| author | mo khan <mo@mokhan.ca> | 2025-07-15 16:37:08 -0600 |
|---|---|---|
| committer | mo khan <mo@mokhan.ca> | 2025-07-17 16:30:22 -0600 |
| commit | 45df4d0d9b577fecee798d672695fe24ff57fb1b (patch) | |
| tree | 1b99bf645035b58e0d6db08c7a83521f41f7a75b /vendor/bytes | |
| parent | f94f79608393d4ab127db63cc41668445ef6b243 (diff) | |
feat: migrate from Cedar to SpiceDB authorization system
This is a major architectural change that replaces the Cedar policy-based
authorization system with SpiceDB's relation-based authorization.
Key changes:
- Migrate from Rust to Go implementation
- Replace Cedar policies with SpiceDB schema and relationships
- Switch from envoy `ext_authz` with Cedar to SpiceDB permission checks
- Update build system and dependencies for Go ecosystem
- Maintain Envoy integration for external authorization
This change enables more flexible permission modeling through SpiceDB's
Google Zanzibar inspired relation-based system, supporting complex
hierarchical permissions that were difficult to express in Cedar.
Breaking change: Existing Cedar policies and Rust-based configuration
will no longer work and need to be migrated to SpiceDB schema.
Diffstat (limited to 'vendor/bytes')
45 files changed, 0 insertions, 14458 deletions
diff --git a/vendor/bytes/.cargo-checksum.json b/vendor/bytes/.cargo-checksum.json deleted file mode 100644 index cb8ef0dd..00000000 --- a/vendor/bytes/.cargo-checksum.json +++ /dev/null @@ -1 +0,0 @@ -{"files":{"CHANGELOG.md":"86affa16d7afc66a1500175b3373e8b35ffce525f8ef51e933b0b2b807b928b7","Cargo.lock":"e50cc260bab7149ad4a10ceedc46e5420ca0305027b60b50d8f26abcb24a3e15","Cargo.toml":"eb4c0ac524e35ea8ccd9bed2b79b69565196bf36029ee1149d684622befa1300","LICENSE":"45f522cacecb1023856e46df79ca625dfc550c94910078bd8aec6e02880b3d42","README.md":"275ac7bc295e3cc659d28f05261645ac5bd6286476afe2ee3c1ed719f7b6df02","SECURITY.md":"a3335079977c2f13bad59e323fdc1056bdae5adfe55f18d15ac2c930d741828c","benches/buf.rs":"72e6b6120b52d568da068f17c66a793d65602e400c595778581b63092e41d8dc","benches/bytes.rs":"7084e564f8568f52c9fdb76a06e58701aa7f0c776209d29a0f60c38a19748203","benches/bytes_mut.rs":"1326fe6224b26826228e02b4133151e756f38152c2d9cfe66adf83af76c3ec98","ci/miri.sh":"13b2db3432fcdf9e2db6ef9e6ec20d063c0ce63542981a6f77e09306e1e2198e","ci/panic-abort.sh":"aec2e5427117e533d7a9721a926eb6a9d72f264510066baf2c501357df2d936f","ci/test-stable.sh":"fb751f06f314f728c489b7a7854701f632e24de8d0540ea8cf3449c6a853ac3c","ci/tsan.sh":"466b86b19225dd26c756cf2252cb1973f87a145642c99364b462ed7ceb55c7dd","clippy.toml":"8522f448dfa3b33ac334ce47d233ebb6b58e8ae115e45107a64fc1b4510fe560","src/buf/buf_impl.rs":"a14aa7e5e7fac1d4d1a3617d616af0b478a9a31235b773bcec11255c8c78446e","src/buf/buf_mut.rs":"6cc3800b08dc36eac3dbe0916be67fa535132c69dd920065efb930fd7c7d0a39","src/buf/chain.rs":"27ff0a6fce049c51a24d45003b9741b655c28330b48af23ad1514587760b0c93","src/buf/iter.rs":"d4dca5b7f9b1cb441f22ac1862e28b10086721879163a810955aefb5cd7f3e58","src/buf/limit.rs":"e005ba140b70f68654877c96b981a220477e415ff5c92438c1b0cb9bc866d872","src/buf/mod.rs":"3f60295316d44b510b942abb31a0d975ae488bd4b52c87f5252d73f88f82715a","src/buf/reader.rs":"cda8bc221a1de06c7395d5c6e80f8a5924198eafbc2decc0909082ce8781d789","src/buf/take.rs":"68053cf0edd9e1abd51b0cac9fefd7d3abfc53d2fde1f44d775399720b2d939e","src/buf/uninit_slice.rs":"52629b93ff7a08db45fc69395580b34fa3609fd9309ea01f86e58488b02b08a3","src/buf/vec_deque.rs":"baac165527d1bdfc3bb259380bb4722e70c3f11e8a901e8bab6e4f951b060711","src/buf/writer.rs":"b137608cb40944a5c3e061a73087c5a48e50048dae002d0334a23cf4d3547065","src/bytes.rs":"1b3935281970640eb2355059584ef75b5655f1abcab6c0bcb60669c5812b34d5","src/bytes_mut.rs":"0498dcaf2b39c0cc4b39c398e095bb4cc0bc001ebc2d90ffd067308e8566b772","src/fmt/debug.rs":"4d217b8f43e489925bb6904010df617efc63b50a3cc1ab126eec54b43b66eb3e","src/fmt/hex.rs":"54c05ab7d95d7381e499079d63773fabd2672f3c4929b56b02ab87d4495902b5","src/fmt/mod.rs":"b38222dcfff70eb3ffb6ce305b95f3fcfd9fa68cca85693eb2ed01d3da7ddb88","src/lib.rs":"6a59680076e75d4b6f966a2202de615ab1107b066b1c8481398131285b6195cf","src/loom.rs":"7c89f9f5f900d5b9b7c43d08d467957933eba90d5dcff1b38cf9a7e48494a577","src/serde.rs":"3ecd7e828cd4c2b7db93c807cb1548fad209e674df493edf7cda69a7b04d405d","tests/test_buf.rs":"c55dc7ab1a7392c2467a079dc77223fbec35ff54e9eda9b05cc1d4e22cb36626","tests/test_buf_mut.rs":"3e6a12a4f546dbf1a0e1346ab2b7ff707fdaf01a06b21714ca64b141484a76c3","tests/test_bytes.rs":"1ef7050f74cdf7c4da1a52a0371303bab6bc181cc91eab6b0b1e20073afc4d9e","tests/test_bytes_odd_alloc.rs":"ad5df84a35038359413199762c65017989d905e6e965a7b863beaa9962a7e1e8","tests/test_bytes_vec_alloc.rs":"5a0e77cab12b32374b2822df8d9a6479afe68b55c1cba1511ebf4199be532caa","tests/test_chain.rs":"e9f094539bb42b3135f50033c44122a6b44cf0f953e51e8b488f43243f1e7f10","tests/test_debug.rs":"13299107172809e8cbbd823964ac9450cd0d6b6de79f2e6a2e0f44b9225a0593","tests/test_iter.rs":"665e1837c1294d7695ffa352a666ce8673fb46fa603164556524e87d5517a6cb","tests/test_reader.rs":"bf83669d4e0960dad6aa47b46a9a454814fab626eb83572aba914c3d71618f43","tests/test_serde.rs":"2691f891796ba259de0ecf926de05c514f4912cc5fcd3e6a1591efbcd23ed4d0","tests/test_take.rs":"fb34700a8ed75b3c6937a4dee0bffadb64f7c7f735bd9faa8730eb96a9e9b651"},"package":"d71b6127be86fdcfddb610f7182ac57211d4b18a3e9c82eb2d17662f2227ad6a"}
\ No newline at end of file diff --git a/vendor/bytes/CHANGELOG.md b/vendor/bytes/CHANGELOG.md deleted file mode 100644 index a98a5c98..00000000 --- a/vendor/bytes/CHANGELOG.md +++ /dev/null @@ -1,426 +0,0 @@ -# 1.10.1 (March 5th, 2025) - -### Fixed - -- Fix memory leak when using `to_vec` with `Bytes::from_owner` (#773) - -# 1.10.0 (February 3rd, 2025) - -### Added - -- Add feature to support platforms without atomic CAS (#467) -- `try_get_*` methods for `Buf` trait (#753) -- Implement `Buf::chunks_vectored` for `Take` (#617) -- Implement `Buf::chunks_vectored` for `VecDeque<u8>` (#708) - -### Fixed - -- Remove incorrect guarantee for `chunks_vectored` (#754) -- Ensure that tests pass under `panic=abort` (#749) - -# 1.9.0 (November 27, 2024) - -### Added - -- Add `Bytes::from_owner` to enable externally-allocated memory (#742) - -### Documented - -- Fix typo in Buf::chunk() comment (#744) - -### Internal changes - -- Replace BufMut::put with BufMut::put_slice in Writer impl (#745) -- Rename hex_impl! to fmt_impl! and reuse it for fmt::Debug (#743) - -# 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. - -### Changed -- `BufMut` is now an `unsafe` trait (#432). -- `BufMut::bytes_mut()` returns `&mut UninitSlice`, a type owned by `bytes` to - avoid undefined behavior (#433). -- `Buf::copy_to_bytes(len)` replaces `Buf::into_bytes()` (#439). -- `Buf`/`BufMut` utility methods are moved onto the trait and `*Ext` traits are - removed (#431). - -### Removed -- `BufMut::bytes_vectored_mut()` (#430). -- `new` methods on combinator types (#434). - -# 0.5.6 (July 13, 2020) - -- Improve `BytesMut` to reuse buffer when fully `advance`d. -- Mark `BytesMut::{as_mut, set_len}` with `#[inline]`. -- Relax synchronization when cloning in shared vtable of `Bytes`. -- Move `loom` to `dev-dependencies`. - -# 0.5.5 (June 18, 2020) - -### Added -- Allow using the `serde` feature in `no_std` environments (#385). - -### Fix -- Fix `BufMut::advance_mut` to panic if advanced passed the capacity (#354).. -- Fix `BytesMut::freeze` ignoring amount previously `advance`d (#352). - -# 0.5.4 (January 23, 2020) - -### Added -- Make `Bytes::new` a `const fn`. -- Add `From<BytesMut>` for `Bytes`. - -### Fix -- Fix reversed arguments in `PartialOrd` for `Bytes`. -- Fix `Bytes::truncate` losing original capacity when repr is an unshared `Vec`. -- Fix `Bytes::from(Vec)` when allocator gave `Vec` a pointer with LSB set. -- Fix panic in `Bytes::slice_ref` if argument is an empty slice. - -# 0.5.3 (December 12, 2019) - -### Added -- `must_use` attributes to `split`, `split_off`, and `split_to` methods (#337). - -### Fix -- Potential freeing of a null pointer in `Bytes` when constructed with an empty `Vec<u8>` (#341, #342). -- Calling `Bytes::truncate` with a size large than the length will no longer clear the `Bytes` (#333). - -# 0.5.2 (November 27, 2019) - -### Added -- `Limit` methods `into_inner`, `get_ref`, `get_mut`, `limit`, and `set_limit` (#325). - -# 0.5.1 (November 25, 2019) - -### Fix -- Growth documentation for `BytesMut` (#321) - -# 0.5.0 (November 25, 2019) - -### Fix -- Potential overflow in `copy_to_slice` - -### Changed -- Increased minimum supported Rust version to 1.39. -- `Bytes` is now a "trait object", allowing for custom allocation strategies (#298) -- `BytesMut` implicitly grows internal storage. `remaining_mut()` returns - `usize::MAX` (#316). -- `BufMut::bytes_mut` returns `&mut [MaybeUninit<u8>]` to reflect the unknown - initialization state (#305). -- `Buf` / `BufMut` implementations for `&[u8]` and `&mut [u8]` - respectively (#261). -- Move `Buf` / `BufMut` "extra" functions to an extension trait (#306). -- `BufMutExt::limit` (#309). -- `Bytes::slice` takes a `RangeBounds` argument (#265). -- `Bytes::from_static` is now a `const fn` (#311). -- A multitude of smaller performance optimizations. - -### Added -- `no_std` support (#281). -- `get_*`, `put_*`, `get_*_le`, and `put_*le` accessors for handling byte order. -- `BorrowMut` implementation for `BytesMut` (#185). - -### Removed -- `IntoBuf` (#288). -- `Buf` implementation for `&str` (#301). -- `byteorder` dependency (#280). -- `iovec` dependency, use `std::IoSlice` instead (#263). -- optional `either` dependency (#315). -- optional `i128` feature -- now available on stable. (#276). - -# 0.4.12 (March 6, 2019) - -### Added -- Implement `FromIterator<&'a u8>` for `BytesMut`/`Bytes` (#244). -- Implement `Buf` for `VecDeque` (#249). - -# 0.4.11 (November 17, 2018) - -* Use raw pointers for potentially racy loads (#233). -* Implement `BufRead` for `buf::Reader` (#232). -* Documentation tweaks (#234). - -# 0.4.10 (September 4, 2018) - -* impl `Buf` and `BufMut` for `Either` (#225). -* Add `Bytes::slice_ref` (#208). - -# 0.4.9 (July 12, 2018) - -* Add 128 bit number support behind a feature flag (#209). -* Implement `IntoBuf` for `&mut [u8]` - -# 0.4.8 (May 25, 2018) - -* Fix panic in `BytesMut` `FromIterator` implementation. -* Bytes: Recycle space when reserving space in vec mode (#197). -* Bytes: Add resize fn (#203). - -# 0.4.7 (April 27, 2018) - -* Make `Buf` and `BufMut` usable as trait objects (#186). -* impl BorrowMut for BytesMut (#185). -* Improve accessor performance (#195). - -# 0.4.6 (Janary 8, 2018) - -* Implement FromIterator for Bytes/BytesMut (#148). -* Add `advance` fn to Bytes/BytesMut (#166). -* Add `unsplit` fn to `BytesMut` (#162, #173). -* Improvements to Bytes split fns (#92). - -# 0.4.5 (August 12, 2017) - -* Fix range bug in `Take::bytes` -* Misc performance improvements -* Add extra `PartialEq` implementations. -* Add `Bytes::with_capacity` -* Implement `AsMut[u8]` for `BytesMut` - -# 0.4.4 (May 26, 2017) - -* Add serde support behind feature flag -* Add `extend_from_slice` on `Bytes` and `BytesMut` -* Add `truncate` and `clear` on `Bytes` -* Misc additional std trait implementations -* Misc performance improvements - -# 0.4.3 (April 30, 2017) - -* Fix Vec::advance_mut bug -* Bump minimum Rust version to 1.15 -* Misc performance tweaks - -# 0.4.2 (April 5, 2017) - -* Misc performance tweaks -* Improved `Debug` implementation for `Bytes` -* Avoid some incorrect assert panics - -# 0.4.1 (March 15, 2017) - -* Expose `buf` module and have most types available from there vs. root. -* Implement `IntoBuf` for `T: Buf`. -* Add `FromBuf` and `Buf::collect`. -* Add iterator adapter for `Buf`. -* Add scatter/gather support to `Buf` and `BufMut`. -* Add `Buf::chain`. -* Reduce allocations on repeated calls to `BytesMut::reserve`. -* Implement `Debug` for more types. -* Remove `Source` in favor of `IntoBuf`. -* Implement `Extend` for `BytesMut`. - - -# 0.4.0 (February 24, 2017) - -* Initial release diff --git a/vendor/bytes/Cargo.lock b/vendor/bytes/Cargo.lock deleted file mode 100644 index 3127ac25..00000000 --- a/vendor/bytes/Cargo.lock +++ /dev/null @@ -1,355 +0,0 @@ -# This file is automatically @generated by Cargo. -# It is not intended for manual editing. -version = 3 - -[[package]] -name = "ansi_term" -version = "0.12.1" -source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "d52a9bb7ec0cf484c551830a7ce27bd20d67eac647e1befb56b0be4ee39a55d2" -dependencies = [ - "winapi", -] - -[[package]] -name = "bytes" -version = "1.10.1" -dependencies = [ - "loom", - "portable-atomic", - "serde", - "serde_test", -] - -[[package]] -name = "cc" -version = "1.0.73" -source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "2fff2a6927b3bb87f9595d67196a70493f627687a71d87a0d692242c33f58c11" - -[[package]] -name = "cfg-if" -version = "1.0.0" -source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "baf1de4339761588bc0619e3cbc0120ee582ebb74b53b4efbf79117bd2da40fd" - -[[package]] -name = "generator" -version = "0.8.1" -source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "186014d53bc231d0090ef8d6f03e0920c54d85a5ed22f4f2f74315ec56cf83fb" -dependencies = [ - "cc", - "cfg-if", - "libc", - "log", - "rustversion", - "windows", -] - -[[package]] -name = "lazy_static" -version = "1.4.0" -source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "e2abad23fbc42b3700f2f279844dc832adb2b2eb069b2df918f455c4e18cc646" - -[[package]] -name = "libc" -version = "0.2.129" -source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "64de3cc433455c14174d42e554d4027ee631c4d046d43e3ecc6efc4636cdc7a7" - -[[package]] -name = "log" -version = "0.4.17" -source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "abb12e687cfb44aa40f41fc3978ef76448f9b6038cad6aef4259d3c095a2382e" -dependencies = [ - "cfg-if", -] - -[[package]] -name = "loom" -version = "0.7.2" -source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "419e0dc8046cb947daa77eb95ae174acfbddb7673b4151f56d1eed8e93fbfaca" -dependencies = [ - "cfg-if", - "generator", - "scoped-tls", - "tracing", - "tracing-subscriber", -] - -[[package]] -name = "matchers" -version = "0.1.0" -source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "8263075bb86c5a1b1427b5ae862e8889656f126e9f77c484496e8b47cf5c5558" -dependencies = [ - "regex-automata", -] - -[[package]] -name = "once_cell" -version = "1.13.0" -source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "18a6dbe30758c9f83eb00cbea4ac95966305f5a7772f3f42ebfc7fc7eddbd8e1" - -[[package]] -name = "pin-project-lite" -version = "0.2.9" -source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "e0a7ae3ac2f1173085d398531c705756c94a4c56843785df85a60c1a0afac116" - -[[package]] -name = "portable-atomic" -version = "1.10.0" -source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "280dc24453071f1b63954171985a0b0d30058d287960968b9b2aca264c8d4ee6" - -[[package]] -name = "regex" -version = "1.6.0" -source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "4c4eb3267174b8c6c2f654116623910a0fef09c4753f8dd83db29c48a0df988b" -dependencies = [ - "regex-syntax", -] - -[[package]] -name = "regex-automata" -version = "0.1.10" -source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "6c230d73fb8d8c1b9c0b3135c5142a8acee3a0558fb8db5cf1cb65f8d7862132" -dependencies = [ - "regex-syntax", -] - -[[package]] -name = "regex-syntax" -version = "0.6.27" -source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "a3f87b73ce11b1619a3c6332f45341e0047173771e8b8b73f87bfeefb7b56244" - -[[package]] -name = "rustversion" -version = "1.0.9" -source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "97477e48b4cf8603ad5f7aaf897467cf42ab4218a38ef76fb14c2d6773a6d6a8" - -[[package]] -name = "scoped-tls" -version = "1.0.0" -source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "ea6a9290e3c9cf0f18145ef7ffa62d68ee0bf5fcd651017e586dc7fd5da448c2" - -[[package]] -name = "serde" -version = "1.0.143" -source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "53e8e5d5b70924f74ff5c6d64d9a5acd91422117c60f48c4e07855238a254553" - -[[package]] -name = "serde_test" -version = "1.0.143" -source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "d4b5b007c1bccdc70f8d8b5804da305a64d4279f990f1ae9e3b06eaae46f42e0" -dependencies = [ - "serde", -] - -[[package]] -name = "sharded-slab" -version = "0.1.4" -source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "900fba806f70c630b0a382d0d825e17a0f19fcd059a2ade1ff237bcddf446b31" -dependencies = [ - "lazy_static", -] - -[[package]] -name = "smallvec" -version = "1.9.0" -source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "2fd0db749597d91ff862fd1d55ea87f7855a744a8425a64695b6fca237d1dad1" - -[[package]] -name = "thread_local" -version = "1.1.4" -source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "5516c27b78311c50bf42c071425c560ac799b11c30b31f87e3081965fe5e0180" -dependencies = [ - "once_cell", -] - -[[package]] -name = "tracing" -version = "0.1.36" -source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "2fce9567bd60a67d08a16488756721ba392f24f29006402881e43b19aac64307" -dependencies = [ - "cfg-if", - "pin-project-lite", - "tracing-core", -] - -[[package]] -name = "tracing-core" -version = "0.1.29" -source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "5aeea4303076558a00714b823f9ad67d58a3bbda1df83d8827d21193156e22f7" -dependencies = [ - "once_cell", - "valuable", -] - -[[package]] -name = "tracing-log" -version = "0.1.3" -source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "78ddad33d2d10b1ed7eb9d1f518a5674713876e97e5bb9b7345a7984fbb4f922" -dependencies = [ - "lazy_static", - "log", - "tracing-core", -] - -[[package]] -name = "tracing-subscriber" -version = "0.3.15" -source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "60db860322da191b40952ad9affe65ea23e7dd6a5c442c2c42865810c6ab8e6b" -dependencies = [ - "ansi_term", - "matchers", - "once_cell", - "regex", - "sharded-slab", - "smallvec", - "thread_local", - "tracing", - "tracing-core", - "tracing-log", -] - -[[package]] -name = "valuable" -version = "0.1.0" -source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "830b7e5d4d90034032940e4ace0d9a9a057e7a45cd94e6c007832e39edb82f6d" - -[[package]] -name = "winapi" -version = "0.3.9" -source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "5c839a674fcd7a98952e593242ea400abe93992746761e38641405d28b00f419" -dependencies = [ - "winapi-i686-pc-windows-gnu", - "winapi-x86_64-pc-windows-gnu", -] - -[[package]] -name = "winapi-i686-pc-windows-gnu" -version = "0.4.0" -source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "ac3b87c63620426dd9b991e5ce0329eff545bccbbb34f3be09ff6fb6ab51b7b6" - -[[package]] -name = "winapi-x86_64-pc-windows-gnu" -version = "0.4.0" -source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "712e227841d057c1ee1cd2fb22fa7e5a5461ae8e48fa2ca79ec42cfc1931183f" - -[[package]] -name = "windows" -version = "0.54.0" -source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "9252e5725dbed82865af151df558e754e4a3c2c30818359eb17465f1346a1b49" -dependencies = [ - "windows-core", - "windows-targets", -] - -[[package]] -name = "windows-core" -version = "0.54.0" -source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "12661b9c89351d684a50a8a643ce5f608e20243b9fb84687800163429f161d65" -dependencies = [ - "windows-result", - "windows-targets", -] - -[[package]] -name = "windows-result" -version = "0.1.1" -source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "749f0da9cc72d82e600d8d2e44cadd0b9eedb9038f71a1c58556ac1c5791813b" -dependencies = [ - "windows-targets", -] - -[[package]] -name = "windows-targets" -version = "0.52.5" -source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "6f0713a46559409d202e70e28227288446bf7841d3211583a4b53e3f6d96e7eb" -dependencies = [ - "windows_aarch64_gnullvm", - "windows_aarch64_msvc", - "windows_i686_gnu", - "windows_i686_gnullvm", - "windows_i686_msvc", - "windows_x86_64_gnu", - "windows_x86_64_gnullvm", - "windows_x86_64_msvc", -] - -[[package]] -name = "windows_aarch64_gnullvm" -version = "0.52.5" -source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "7088eed71e8b8dda258ecc8bac5fb1153c5cffaf2578fc8ff5d61e23578d3263" - -[[package]] -name = "windows_aarch64_msvc" -version = "0.52.5" -source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "9985fd1504e250c615ca5f281c3f7a6da76213ebd5ccc9561496568a2752afb6" - -[[package]] -name = "windows_i686_gnu" -version = "0.52.5" -source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "88ba073cf16d5372720ec942a8ccbf61626074c6d4dd2e745299726ce8b89670" - -[[package]] -name = "windows_i686_gnullvm" -version = "0.52.5" -source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "87f4261229030a858f36b459e748ae97545d6f1ec60e5e0d6a3d32e0dc232ee9" - -[[package]] -name = "windows_i686_msvc" -version = "0.52.5" -source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "db3c2bf3d13d5b658be73463284eaf12830ac9a26a90c717b7f771dfe97487bf" - -[[package]] -name = "windows_x86_64_gnu" -version = "0.52.5" -source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "4e4246f76bdeff09eb48875a0fd3e2af6aada79d409d33011886d3e1581517d9" - -[[package]] -name = "windows_x86_64_gnullvm" -version = "0.52.5" -source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "852298e482cd67c356ddd9570386e2862b5673c85bd5f88df9ab6802b334c596" - -[[package]] -name = "windows_x86_64_msvc" -version = "0.52.5" -source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "bec47e5bfd1bff0eeaf6d8b485cc1074891a197ab4225d504cb7a1ab88b02bf0" diff --git a/vendor/bytes/Cargo.toml b/vendor/bytes/Cargo.toml deleted file mode 100644 index cf4f9f49..00000000 --- a/vendor/bytes/Cargo.toml +++ /dev/null @@ -1,133 +0,0 @@ -# THIS FILE IS AUTOMATICALLY GENERATED BY CARGO -# -# When uploading crates to the registry Cargo will automatically -# "normalize" Cargo.toml files for maximal compatibility -# with all versions of Cargo and also rewrite `path` dependencies -# to registry (e.g., crates.io) dependencies. -# -# If you are reading this file be aware that the original Cargo.toml -# will likely look very different (and much more reasonable). -# See Cargo.toml.orig for the original contents. - -[package] -edition = "2018" -rust-version = "1.39" -name = "bytes" -version = "1.10.1" -authors = [ - "Carl Lerche <me@carllerche.com>", - "Sean McArthur <sean@seanmonstar.com>", -] -build = false -autolib = false -autobins = false -autoexamples = false -autotests = false -autobenches = false -description = "Types and traits for working with bytes" -readme = "README.md" -keywords = [ - "buffers", - "zero-copy", - "io", -] -categories = [ - "network-programming", - "data-structures", -] -license = "MIT" -repository = "https://github.com/tokio-rs/bytes" - -[package.metadata.docs.rs] -rustdoc-args = [ - "--cfg", - "docsrs", -] - -[features] -default = ["std"] -std = [] - -[lib] -name = "bytes" -path = "src/lib.rs" - -[[test]] -name = "test_buf" -path = "tests/test_buf.rs" - -[[test]] -name = "test_buf_mut" -path = "tests/test_buf_mut.rs" - -[[test]] -name = "test_bytes" -path = "tests/test_bytes.rs" - -[[test]] -name = "test_bytes_odd_alloc" -path = "tests/test_bytes_odd_alloc.rs" - -[[test]] -name = "test_bytes_vec_alloc" -path = "tests/test_bytes_vec_alloc.rs" - -[[test]] -name = "test_chain" -path = "tests/test_chain.rs" - -[[test]] -name = "test_debug" -path = "tests/test_debug.rs" - -[[test]] -name = "test_iter" -path = "tests/test_iter.rs" - -[[test]] -name = "test_reader" -path = "tests/test_reader.rs" - -[[test]] -name = "test_serde" -path = "tests/test_serde.rs" - -[[test]] -name = "test_take" -path = "tests/test_take.rs" - -[[bench]] -name = "buf" -path = "benches/buf.rs" - -[[bench]] -name = "bytes" -path = "benches/bytes.rs" - -[[bench]] -name = "bytes_mut" -path = "benches/bytes_mut.rs" - -[dependencies.extra-platforms] -version = "1.3" -features = ["require-cas"] -optional = true -default-features = false -package = "portable-atomic" - -[dependencies.serde] -version = "1.0.60" -features = ["alloc"] -optional = true -default-features = false - -[dev-dependencies.serde_test] -version = "1.0" - -[target."cfg(loom)".dev-dependencies.loom] -version = "0.7" - -[lints.rust.unexpected_cfgs] -level = "warn" -priority = 0 -check-cfg = ["cfg(loom)"] diff --git a/vendor/bytes/LICENSE b/vendor/bytes/LICENSE deleted file mode 100644 index 58fb29a1..00000000 --- a/vendor/bytes/LICENSE +++ /dev/null @@ -1,25 +0,0 @@ -Copyright (c) 2018 Carl Lerche - -Permission is hereby granted, free of charge, to any -person obtaining a copy of this software and associated -documentation files (the "Software"), to deal in the -Software without restriction, including without -limitation the rights to use, copy, modify, merge, -publish, distribute, sublicense, and/or sell copies of -the Software, and to permit persons to whom the Software -is furnished to do so, subject to the following -conditions: - -The above copyright notice and this permission notice -shall be included in all copies or substantial portions -of the Software. - -THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF -ANY KIND, EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED -TO THE WARRANTIES OF MERCHANTABILITY, FITNESS FOR A -PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT -SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY -CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION -OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR -IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER -DEALINGS IN THE SOFTWARE. diff --git a/vendor/bytes/README.md b/vendor/bytes/README.md deleted file mode 100644 index 90d631c9..00000000 --- a/vendor/bytes/README.md +++ /dev/null @@ -1,73 +0,0 @@ -# Bytes - -A utility library for working with bytes. - -[![Crates.io][crates-badge]][crates-url] -[![Build Status][ci-badge]][ci-url] - -[crates-badge]: https://img.shields.io/crates/v/bytes.svg -[crates-url]: https://crates.io/crates/bytes -[ci-badge]: https://github.com/tokio-rs/bytes/workflows/CI/badge.svg -[ci-url]: https://github.com/tokio-rs/bytes/actions - -[Documentation](https://docs.rs/bytes) - -## Usage - -To use `bytes`, first add this to your `Cargo.toml`: - -```toml -[dependencies] -bytes = "1" -``` - -Next, add this to your crate: - -```rust -use bytes::{Bytes, BytesMut, Buf, BufMut}; -``` - -## no_std support - -To use `bytes` with no_std environment, disable the (enabled by default) `std` feature. - -```toml -[dependencies] -bytes = { version = "1", default-features = false } -``` - -To use `bytes` with no_std environment without atomic CAS, such as thumbv6m, you also need to enable -the `extra-platforms` feature. See the [documentation for the `portable-atomic` -crate](https://docs.rs/portable-atomic) for more information. - -The MSRV when `extra-platforms` feature is enabled depends on the MSRV of `portable-atomic`. - -## Serde support - -Serde support is optional and disabled by default. To enable use the feature `serde`. - -```toml -[dependencies] -bytes = { version = "1", features = ["serde"] } -``` - -The MSRV when `serde` feature is enabled depends on the MSRV of `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 -``` - -## License - -This project is licensed under the [MIT license](LICENSE). - -### Contribution - -Unless you explicitly state otherwise, any contribution intentionally submitted -for inclusion in `bytes` by you, shall be licensed as MIT, without any additional -terms or conditions. diff --git a/vendor/bytes/SECURITY.md b/vendor/bytes/SECURITY.md deleted file mode 100644 index b74a831c..00000000 --- a/vendor/bytes/SECURITY.md +++ /dev/null @@ -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 diff --git a/vendor/bytes/benches/buf.rs b/vendor/bytes/benches/buf.rs deleted file mode 100644 index 616d1874..00000000 --- a/vendor/bytes/benches/buf.rs +++ /dev/null @@ -1,186 +0,0 @@ -#![feature(test)] -#![warn(rust_2018_idioms)] - -extern crate test; - -use bytes::Buf; -use test::Bencher; - -/// Dummy Buf implementation -struct TestBuf { - buf: &'static [u8], - readlens: &'static [usize], - init_pos: usize, - pos: usize, - readlen_pos: usize, - readlen: usize, -} -impl TestBuf { - fn new(buf: &'static [u8], readlens: &'static [usize], init_pos: usize) -> TestBuf { - let mut buf = TestBuf { - buf, - readlens, - init_pos, - pos: 0, - readlen_pos: 0, - readlen: 0, - }; - buf.reset(); - buf - } - fn reset(&mut self) { - self.pos = self.init_pos; - self.readlen_pos = 0; - self.next_readlen(); - } - /// Compute the length of the next read : - /// - use the next value specified in readlens (capped by remaining) if any - /// - else the remaining - fn next_readlen(&mut self) { - self.readlen = self.buf.len() - self.pos; - if let Some(readlen) = self.readlens.get(self.readlen_pos) { - self.readlen = std::cmp::min(self.readlen, *readlen); - self.readlen_pos += 1; - } - } -} -impl Buf for TestBuf { - fn remaining(&self) -> usize { - 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] { - if self.readlen == 0 { - Default::default() - } else { - &self.buf[self.pos..self.pos + self.readlen] - } - } -} - -/// Dummy Buf implementation -/// version with methods forced to not be inlined (to simulate costly calls) -struct TestBufC { - inner: TestBuf, -} -impl TestBufC { - fn new(buf: &'static [u8], readlens: &'static [usize], init_pos: usize) -> TestBufC { - TestBufC { - inner: TestBuf::new(buf, readlens, init_pos), - } - } - fn reset(&mut self) { - self.inner.reset() - } -} -impl Buf for TestBufC { - #[inline(never)] - fn remaining(&self) -> usize { - self.inner.remaining() - } - #[inline(never)] - fn advance(&mut self, cnt: usize) { - self.inner.advance(cnt) - } - #[inline(never)] - fn chunk(&self) -> &[u8] { - self.inner.chunk() - } -} - -macro_rules! bench { - ($fname:ident, testbuf $testbuf:ident $readlens:expr, $method:ident $(,$arg:expr)*) => ( - #[bench] - fn $fname(b: &mut Bencher) { - let mut bufs = [ - $testbuf::new(&[1u8; 8+0], $readlens, 0), - $testbuf::new(&[1u8; 8+1], $readlens, 1), - $testbuf::new(&[1u8; 8+2], $readlens, 2), - $testbuf::new(&[1u8; 8+3], $readlens, 3), - $testbuf::new(&[1u8; 8+4], $readlens, 4), - $testbuf::new(&[1u8; 8+5], $readlens, 5), - $testbuf::new(&[1u8; 8+6], $readlens, 6), - $testbuf::new(&[1u8; 8+7], $readlens, 7), - ]; - b.iter(|| { - for i in 0..8 { - bufs[i].reset(); - let buf: &mut dyn Buf = &mut bufs[i]; // type erasure - test::black_box(buf.$method($($arg,)*)); - } - }) - } - ); - ($fname:ident, slice, $method:ident $(,$arg:expr)*) => ( - #[bench] - fn $fname(b: &mut Bencher) { - // buf must be long enough for one read of 8 bytes starting at pos 7 - let arr = [1u8; 8+7]; - b.iter(|| { - for i in 0..8 { - let mut buf = &arr[i..]; - let buf = &mut buf as &mut dyn Buf; // type erasure - test::black_box(buf.$method($($arg,)*)); - } - }) - } - ); - ($fname:ident, option) => ( - #[bench] - fn $fname(b: &mut Bencher) { - let data = [1u8; 1]; - b.iter(|| { - for _ in 0..8 { - let mut buf = Some(data); - let buf = &mut buf as &mut dyn Buf; // type erasure - test::black_box(buf.get_u8()); - } - }) - } - ); -} - -macro_rules! bench_group { - ($method:ident $(,$arg:expr)*) => ( - bench!(slice, slice, $method $(,$arg)*); - bench!(tbuf_1, testbuf TestBuf &[], $method $(,$arg)*); - bench!(tbuf_1_costly, testbuf TestBufC &[], $method $(,$arg)*); - bench!(tbuf_2, testbuf TestBuf &[1], $method $(,$arg)*); - bench!(tbuf_2_costly, testbuf TestBufC &[1], $method $(,$arg)*); - // bench!(tbuf_onebyone, testbuf TestBuf &[1,1,1,1,1,1,1,1], $method $(,$arg)*); - // bench!(tbuf_onebyone_costly, testbuf TestBufC &[1,1,1,1,1,1,1,1], $method $(,$arg)*); - ); -} - -mod get_u8 { - use super::*; - bench_group!(get_u8); -} -mod get_u16 { - use super::*; - bench_group!(get_u16); -} -mod get_u32 { - use super::*; - bench_group!(get_u32); -} -mod get_u64 { - use super::*; - bench_group!(get_u64); -} -mod get_f32 { - use super::*; - bench_group!(get_f32); -} -mod get_f64 { - use super::*; - bench_group!(get_f64); -} -mod get_uint24 { - use super::*; - bench_group!(get_uint, 3); -} diff --git a/vendor/bytes/benches/bytes.rs b/vendor/bytes/benches/bytes.rs deleted file mode 100644 index 8782d006..00000000 --- a/vendor/bytes/benches/bytes.rs +++ /dev/null @@ -1,120 +0,0 @@ -#![feature(test)] -#![warn(rust_2018_idioms)] - -extern crate test; - -use bytes::Bytes; -use test::Bencher; - -#[bench] -fn deref_unique(b: &mut Bencher) { - let buf = Bytes::from(vec![0; 1024]); - - b.iter(|| { - for _ in 0..1024 { - test::black_box(&buf[..]); - } - }) -} - -#[bench] -fn deref_shared(b: &mut Bencher) { - let buf = Bytes::from(vec![0; 1024]); - let _b2 = buf.clone(); - - b.iter(|| { - for _ in 0..1024 { - test::black_box(&buf[..]); - } - }) -} - -#[bench] -fn deref_static(b: &mut Bencher) { - let buf = Bytes::from_static(b"hello world"); - - b.iter(|| { - for _ in 0..1024 { - test::black_box(&buf[..]); - } - }) -} - -#[bench] -fn clone_static(b: &mut Bencher) { - let bytes = - Bytes::from_static("hello world 1234567890 and have a good byte 0987654321".as_bytes()); - - b.iter(|| { - for _ in 0..1024 { - test::black_box(test::black_box(&bytes).clone()); - } - }) -} - -#[bench] -fn clone_shared(b: &mut Bencher) { - let bytes = Bytes::from(b"hello world 1234567890 and have a good byte 0987654321".to_vec()); - - b.iter(|| { - for _ in 0..1024 { - test::black_box(test::black_box(&bytes).clone()); - } - }) -} - -#[bench] -fn clone_arc_vec(b: &mut Bencher) { - use std::sync::Arc; - let bytes = Arc::new(b"hello world 1234567890 and have a good byte 0987654321".to_vec()); - - b.iter(|| { - for _ in 0..1024 { - test::black_box(test::black_box(&bytes).clone()); - } - }) -} - -#[bench] -fn from_long_slice(b: &mut Bencher) { - let data = [0u8; 128]; - b.bytes = data.len() as u64; - b.iter(|| { - let buf = Bytes::copy_from_slice(&data[..]); - test::black_box(buf); - }) -} - -#[bench] -fn slice_empty(b: &mut Bencher) { - b.iter(|| { - // `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)); - } - }) -} - -#[bench] -fn slice_short_from_arc(b: &mut Bencher) { - b.iter(|| { - // `clone` is to convert to ARC - let b = Bytes::from(vec![17; 1024]).clone(); - for i in 0..1000 { - test::black_box(b.slice(1..2 + i % 10)); - } - }) -} - -#[bench] -fn split_off_and_drop(b: &mut Bencher) { - b.iter(|| { - for _ in 0..1024 { - let v = vec![10; 200]; - let mut b = Bytes::from(v); - test::black_box(b.split_off(100)); - test::black_box(b); - } - }) -} diff --git a/vendor/bytes/benches/bytes_mut.rs b/vendor/bytes/benches/bytes_mut.rs deleted file mode 100644 index b0694362..00000000 --- a/vendor/bytes/benches/bytes_mut.rs +++ /dev/null @@ -1,266 +0,0 @@ -#![feature(test)] -#![warn(rust_2018_idioms)] - -extern crate test; - -use bytes::{BufMut, BytesMut}; -use test::Bencher; - -#[bench] -fn alloc_small(b: &mut Bencher) { - b.iter(|| { - for _ in 0..1024 { - test::black_box(BytesMut::with_capacity(12)); - } - }) -} - -#[bench] -fn alloc_mid(b: &mut Bencher) { - b.iter(|| { - test::black_box(BytesMut::with_capacity(128)); - }) -} - -#[bench] -fn alloc_big(b: &mut Bencher) { - b.iter(|| { - test::black_box(BytesMut::with_capacity(4096)); - }) -} - -#[bench] -fn deref_unique(b: &mut Bencher) { - let mut buf = BytesMut::with_capacity(4096); - buf.put(&[0u8; 1024][..]); - - b.iter(|| { - for _ in 0..1024 { - test::black_box(&buf[..]); - } - }) -} - -#[bench] -fn deref_unique_unroll(b: &mut Bencher) { - let mut buf = BytesMut::with_capacity(4096); - buf.put(&[0u8; 1024][..]); - - b.iter(|| { - for _ in 0..128 { - test::black_box(&buf[..]); - test::black_box(&buf[..]); - test::black_box(&buf[..]); - test::black_box(&buf[..]); - test::black_box(&buf[..]); - test::black_box(&buf[..]); - test::black_box(&buf[..]); - test::black_box(&buf[..]); - } - }) -} - -#[bench] -fn deref_shared(b: &mut Bencher) { - let mut buf = BytesMut::with_capacity(4096); - buf.put(&[0u8; 1024][..]); - let _b2 = buf.split_off(1024); - - b.iter(|| { - for _ in 0..1024 { - test::black_box(&buf[..]); - } - }) -} - -#[bench] -fn deref_two(b: &mut Bencher) { - let mut buf1 = BytesMut::with_capacity(8); - buf1.put(&[0u8; 8][..]); - - let mut buf2 = BytesMut::with_capacity(4096); - buf2.put(&[0u8; 1024][..]); - - b.iter(|| { - for _ in 0..512 { - test::black_box(&buf1[..]); - test::black_box(&buf2[..]); - } - }) -} - -#[bench] -fn clone_frozen(b: &mut Bencher) { - let bytes = BytesMut::from(&b"hello world 1234567890 and have a good byte 0987654321"[..]) - .split() - .freeze(); - - b.iter(|| { - for _ in 0..1024 { - test::black_box(&bytes.clone()); - } - }) -} - -#[bench] -fn alloc_write_split_to_mid(b: &mut Bencher) { - b.iter(|| { - let mut buf = BytesMut::with_capacity(128); - buf.put_slice(&[0u8; 64]); - test::black_box(buf.split_to(64)); - }) -} - -#[bench] -fn drain_write_drain(b: &mut Bencher) { - let data = [0u8; 128]; - - b.iter(|| { - let mut buf = BytesMut::with_capacity(1024); - let mut parts = Vec::with_capacity(8); - - for _ in 0..8 { - buf.put(&data[..]); - parts.push(buf.split_to(128)); - } - - test::black_box(parts); - }) -} - -#[bench] -fn fmt_write(b: &mut Bencher) { - use std::fmt::Write; - let mut buf = BytesMut::with_capacity(128); - let s = "foo bar baz quux lorem ipsum dolor et"; - - b.bytes = s.len() as u64; - b.iter(|| { - let _ = write!(buf, "{}", s); - test::black_box(&buf); - unsafe { - buf.set_len(0); - } - }) -} - -#[bench] -fn bytes_mut_extend(b: &mut Bencher) { - let mut buf = BytesMut::with_capacity(256); - let data = [33u8; 32]; - - b.bytes = data.len() as u64 * 4; - b.iter(|| { - for _ in 0..4 { - buf.extend(&data); - } - test::black_box(&buf); - unsafe { - buf.set_len(0); - } - }); -} - -// BufMut for BytesMut vs Vec<u8> - -#[bench] -fn put_slice_bytes_mut(b: &mut Bencher) { - let mut buf = BytesMut::with_capacity(256); - let data = [33u8; 32]; - - b.bytes = data.len() as u64 * 4; - b.iter(|| { - for _ in 0..4 { - buf.put_slice(&data); - } - test::black_box(&buf); - unsafe { - buf.set_len(0); - } - }); -} - -#[bench] -fn put_u8_bytes_mut(b: &mut Bencher) { - let mut buf = BytesMut::with_capacity(256); - let cnt = 128; - - b.bytes = cnt as u64; - b.iter(|| { - for _ in 0..cnt { - buf.put_u8(b'x'); - } - test::black_box(&buf); - unsafe { - buf.set_len(0); - } - }); -} - -#[bench] -fn put_slice_vec(b: &mut Bencher) { - let mut buf = Vec::<u8>::with_capacity(256); - let data = [33u8; 32]; - - b.bytes = data.len() as u64 * 4; - b.iter(|| { - for _ in 0..4 { - buf.put_slice(&data); - } - test::black_box(&buf); - unsafe { - buf.set_len(0); - } - }); -} - -#[bench] -fn put_u8_vec(b: &mut Bencher) { - let mut buf = Vec::<u8>::with_capacity(256); - let cnt = 128; - - b.bytes = cnt as u64; - b.iter(|| { - for _ in 0..cnt { - buf.put_u8(b'x'); - } - test::black_box(&buf); - unsafe { - buf.set_len(0); - } - }); -} - -#[bench] -fn put_slice_vec_extend(b: &mut Bencher) { - let mut buf = Vec::<u8>::with_capacity(256); - let data = [33u8; 32]; - - b.bytes = data.len() as u64 * 4; - b.iter(|| { - for _ in 0..4 { - buf.extend_from_slice(&data); - } - test::black_box(&buf); - unsafe { - buf.set_len(0); - } - }); -} - -#[bench] -fn put_u8_vec_push(b: &mut Bencher) { - let mut buf = Vec::<u8>::with_capacity(256); - let cnt = 128; - - b.bytes = cnt as u64; - b.iter(|| { - for _ in 0..cnt { - buf.push(b'x'); - } - test::black_box(&buf); - unsafe { - buf.set_len(0); - } - }); -} diff --git a/vendor/bytes/ci/miri.sh b/vendor/bytes/ci/miri.sh deleted file mode 100755 index 7df29f36..00000000 --- a/vendor/bytes/ci/miri.sh +++ /dev/null @@ -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 diff --git a/vendor/bytes/ci/panic-abort.sh b/vendor/bytes/ci/panic-abort.sh deleted file mode 100755 index 4284791f..00000000 --- a/vendor/bytes/ci/panic-abort.sh +++ /dev/null @@ -1,4 +0,0 @@ -#!/bin/bash - -set -ex -RUSTFLAGS="$RUSTFLAGS -Cpanic=abort -Zpanic-abort-tests" cargo test --all-features --test '*' diff --git a/vendor/bytes/ci/test-stable.sh b/vendor/bytes/ci/test-stable.sh deleted file mode 100755 index ad975744..00000000 --- a/vendor/bytes/ci/test-stable.sh +++ /dev/null @@ -1,25 +0,0 @@ -#!/bin/bash - -set -ex - -cmd="${1:-test}" - -# Run with each feature -# * --each-feature includes both default/no-default features -# * --optional-deps is needed for serde feature -cargo hack "${cmd}" --each-feature --optional-deps -# Run with all features -cargo "${cmd}" --all-features - -if [[ "${RUST_VERSION}" == "nightly"* ]]; then - # Check benchmarks - cargo check --benches - - # Check minimal versions - # Remove dev-dependencies from Cargo.toml to prevent the next `cargo update` - # from determining minimal versions based on dev-dependencies. - cargo hack --remove-dev-deps --workspace - # Update Cargo.lock to minimal version dependencies. - cargo update -Z minimal-versions - cargo check --all-features -fi diff --git a/vendor/bytes/ci/tsan.sh b/vendor/bytes/ci/tsan.sh deleted file mode 100755 index ca520bd7..00000000 --- a/vendor/bytes/ci/tsan.sh +++ /dev/null @@ -1,13 +0,0 @@ -#!/bin/bash - -set -ex - -export ASAN_OPTIONS="detect_odr_violation=0 detect_leaks=0" - -# Run address sanitizer -RUSTFLAGS="-Z sanitizer=address" \ -cargo test --target x86_64-unknown-linux-gnu --test test_bytes --test test_buf --test test_buf_mut - -# Run thread sanitizer -RUSTFLAGS="-Z sanitizer=thread" \ -cargo -Zbuild-std test --target x86_64-unknown-linux-gnu --test test_bytes --test test_buf --test test_buf_mut diff --git a/vendor/bytes/clippy.toml b/vendor/bytes/clippy.toml deleted file mode 100644 index 53095b15..00000000 --- a/vendor/bytes/clippy.toml +++ /dev/null @@ -1 +0,0 @@ -msrv = "1.39" diff --git a/vendor/bytes/src/buf/buf_impl.rs b/vendor/bytes/src/buf/buf_impl.rs deleted file mode 100644 index 192034fb..00000000 --- a/vendor/bytes/src/buf/buf_impl.rs +++ /dev/null @@ -1,2962 +0,0 @@ -#[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, TryGetError}; - -#[cfg(feature = "std")] -use std::io::IoSlice; - -use alloc::boxed::Box; - -macro_rules! buf_try_get_impl { - ($this:ident, $typ:tt::$conv:tt) => {{ - const SIZE: usize = core::mem::size_of::<$typ>(); - - if $this.remaining() < SIZE { - return Err(TryGetError { - requested: SIZE, - available: $this.remaining(), - }); - } - - // 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() - .get(..SIZE) - .map(|src| unsafe { $typ::$conv(*(src as *const _ as *const [_; SIZE])) }); - - if let Some(ret) = ret { - // if the direct conversion was possible, advance and return - $this.advance(SIZE); - return Ok(ret); - } else { - // if not we copy the bytes in a temp buffer then convert - let mut buf = [0; SIZE]; - $this.copy_to_slice(&mut buf); // (do the advance) - return Ok($typ::$conv(buf)); - } - }}; - (le => $this:ident, $typ:tt, $len_to_read:expr) => {{ - const SIZE: usize = core::mem::size_of::<$typ>(); - - // 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.try_copy_to_slice(subslice)?; - return Ok($typ::from_le_bytes(buf)); - }}; - (be => $this:ident, $typ:tt, $len_to_read:expr) => {{ - const SIZE: usize = core::mem::size_of::<$typ>(); - - 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.try_copy_to_slice(&mut buf[slice_at..])?; - return Ok($typ::from_be_bytes(buf)); - }}; -} - -macro_rules! buf_get_impl { - ($this:ident, $typ:tt::$conv:tt) => {{ - return (|| buf_try_get_impl!($this, $typ::$conv))() - .unwrap_or_else(|error| panic_advance(&error)); - }}; - (le => $this:ident, $typ:tt, $len_to_read:expr) => {{ - return (|| buf_try_get_impl!(le => $this, $typ, $len_to_read))() - .unwrap_or_else(|error| panic_advance(&error)); - }}; - (be => $this:ident, $typ:tt, $len_to_read:expr) => {{ - return (|| buf_try_get_impl!(be => $this, $typ, $len_to_read))() - .unwrap_or_else(|error| panic_advance(&error)); - }}; -} - -// 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. -/// The underlying storage may or may not be in contiguous memory. A `Buf` value -/// is a cursor into the buffer. Reading from `Buf` advances the cursor -/// position. It can be thought of as an efficient `Iterator` for collections of -/// bytes. -/// -/// The simplest `Buf` is a `&[u8]`. -/// -/// ``` -/// use bytes::Buf; -/// -/// let mut buf = &b"hello world"[..]; -/// -/// assert_eq!(b'h', buf.get_u8()); -/// assert_eq!(b'e', buf.get_u8()); -/// assert_eq!(b'l', buf.get_u8()); -/// -/// let mut rest = [0; 8]; -/// buf.copy_to_slice(&mut rest); -/// -/// assert_eq!(&rest[..], &b"lo world"[..]); -/// ``` -pub trait Buf { - /// Returns the number of bytes between the current position and the end of - /// the buffer. - /// - /// This value is greater than or equal to the length of the slice returned - /// by `chunk()`. - /// - /// # Examples - /// - /// ``` - /// use bytes::Buf; - /// - /// let mut buf = &b"hello world"[..]; - /// - /// assert_eq!(buf.remaining(), 11); - /// - /// buf.get_u8(); - /// - /// assert_eq!(buf.remaining(), 10); - /// ``` - /// - /// # Implementer notes - /// - /// Implementations of `remaining` should ensure that the return value does - /// not change unless a call is made to `advance` or any other function that - /// is documented to change the `Buf`'s current position. - fn remaining(&self) -> usize; - - /// Returns a slice starting at the current position and of length between 0 - /// and `Buf::remaining()`. Note that this *can* return a shorter slice (this - /// allows non-continuous internal representation). - /// - /// This is a lower level function. Most operations are done with other - /// functions. - /// - /// # Examples - /// - /// ``` - /// use bytes::Buf; - /// - /// let mut buf = &b"hello world"[..]; - /// - /// assert_eq!(buf.chunk(), &b"hello world"[..]); - /// - /// buf.advance(6); - /// - /// assert_eq!(buf.chunk(), &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]; - - /// 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 - /// 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 written to `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. The return value is the number of - /// slices written to `dst`. If `Buf::remaining()` is non-zero, then this - /// writes at least one non-empty slice to `dst`. - /// - /// This is a lower level function. Most operations are done with other - /// functions. - /// - /// # Implementer notes - /// - /// This function should never panic. Once the end of the buffer is reached, - /// i.e., `Buf::remaining` returns 0, calls to `chunk_vectored` must return 0 - /// without mutating `dst`. - /// - /// Implementations should also take care to properly handle being called - /// with `dst` being a zero length slice. - /// - /// [`writev`]: http://man7.org/linux/man-pages/man2/readv.2.html - #[cfg(feature = "std")] - #[cfg_attr(docsrs, doc(cfg(feature = "std")))] - fn chunks_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()); - 1 - } else { - 0 - } - } - - /// Advance the internal cursor of the Buf - /// - /// The next call to `chunk()` will return a slice starting `cnt` bytes - /// further into the underlying buffer. - /// - /// # Examples - /// - /// ``` - /// use bytes::Buf; - /// - /// let mut buf = &b"hello world"[..]; - /// - /// assert_eq!(buf.chunk(), &b"hello world"[..]); - /// - /// buf.advance(6); - /// - /// assert_eq!(buf.chunk(), &b"world"[..]); - /// ``` - /// - /// # Panics - /// - /// This function **may** panic if `cnt > self.remaining()`. - /// - /// # Implementer notes - /// - /// It is recommended for implementations of `advance` to panic if `cnt > - /// self.remaining()`. If the implementation does not panic, the call must - /// behave as if `cnt == self.remaining()`. - /// - /// A call with `cnt == 0` should never panic and be a no-op. - fn advance(&mut self, cnt: usize); - - /// Returns true if there are any more bytes to consume - /// - /// This is equivalent to `self.remaining() != 0`. - /// - /// # Examples - /// - /// ``` - /// use bytes::Buf; - /// - /// let mut buf = &b"a"[..]; - /// - /// assert!(buf.has_remaining()); - /// - /// buf.get_u8(); - /// - /// assert!(!buf.has_remaining()); - /// ``` - fn has_remaining(&self) -> bool { - self.remaining() > 0 - } - - /// Copies bytes from `self` into `dst`. - /// - /// The cursor is advanced by the number of bytes copied. `self` must have - /// enough remaining bytes to fill `dst`. - /// - /// # Examples - /// - /// ``` - /// use bytes::Buf; - /// - /// let mut buf = &b"hello world"[..]; - /// let mut dst = [0; 5]; - /// - /// buf.copy_to_slice(&mut dst); - /// assert_eq!(&b"hello"[..], &dst); - /// assert_eq!(6, buf.remaining()); - /// ``` - /// - /// # Panics - /// - /// This function panics if `self.remaining() < dst.len()`. - fn copy_to_slice(&mut self, dst: &mut [u8]) { - self.try_copy_to_slice(dst) - .unwrap_or_else(|error| panic_advance(&error)); - } - - /// Gets an unsigned 8 bit integer from `self`. - /// - /// The current position is advanced by 1. - /// - /// # Examples - /// - /// ``` - /// use bytes::Buf; - /// - /// let mut buf = &b"\x08 hello"[..]; - /// assert_eq!(8, buf.get_u8()); - /// ``` - /// - /// # Panics - /// - /// This function panics if there is no more remaining data in `self`. - fn get_u8(&mut self) -> u8 { - if self.remaining() < 1 { - panic_advance(&TryGetError { - requested: 1, - available: 0, - }) - } - let ret = self.chunk()[0]; - self.advance(1); - ret - } - - /// Gets a signed 8 bit integer from `self`. - /// - /// The current position is advanced by 1. - /// - /// # Examples - /// - /// ``` - /// use bytes::Buf; - /// - /// let mut buf = &b"\x08 hello"[..]; - /// assert_eq!(8, buf.get_i8()); - /// ``` - /// - /// # Panics - /// - /// This function panics if there is no more remaining data in `self`. - fn get_i8(&mut self) -> i8 { - if self.remaining() < 1 { - panic_advance(&TryGetError { - requested: 1, - available: 0, - }); - } - let ret = self.chunk()[0] as i8; - self.advance(1); - ret - } - - /// Gets an unsigned 16 bit integer from `self` in big-endian byte order. - /// - /// The current position is advanced by 2. - /// - /// # Examples - /// - /// ``` - /// use bytes::Buf; - /// - /// let mut buf = &b"\x08\x09 hello"[..]; - /// assert_eq!(0x0809, buf.get_u16()); - /// ``` - /// - /// # Panics - /// - /// This function panics if there is not enough remaining data in `self`. - fn get_u16(&mut self) -> u16 { - buf_get_impl!(self, u16::from_be_bytes); - } - - /// Gets an unsigned 16 bit integer from `self` in little-endian byte order. - /// - /// The current position is advanced by 2. - /// - /// # Examples - /// - /// ``` - /// use bytes::Buf; - /// - /// let mut buf = &b"\x09\x08 hello"[..]; - /// assert_eq!(0x0809, buf.get_u16_le()); - /// ``` - /// - /// # Panics - /// - /// This function panics if there is not enough remaining data in `self`. - fn get_u16_le(&mut self) -> u16 { - buf_get_impl!(self, u16::from_le_bytes); - } - - /// Gets 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. - /// - /// # Examples - /// - /// ``` - /// use bytes::Buf; - /// - /// let mut buf = &b"\x08\x09 hello"[..]; - /// assert_eq!(0x0809, buf.get_i16()); - /// ``` - /// - /// # Panics - /// - /// This function panics if there is not enough remaining data in `self`. - fn get_i16(&mut self) -> i16 { - buf_get_impl!(self, i16::from_be_bytes); - } - - /// Gets a signed 16 bit integer from `self` in little-endian byte order. - /// - /// The current position is advanced by 2. - /// - /// # Examples - /// - /// ``` - /// use bytes::Buf; - /// - /// let mut buf = &b"\x09\x08 hello"[..]; - /// assert_eq!(0x0809, buf.get_i16_le()); - /// ``` - /// - /// # Panics - /// - /// This function panics if there is not enough remaining data in `self`. - fn get_i16_le(&mut self) -> i16 { - buf_get_impl!(self, i16::from_le_bytes); - } - - /// Gets 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. - /// - /// # Examples - /// - /// ``` - /// use bytes::Buf; - /// - /// let mut buf = &b"\x08\x09\xA0\xA1 hello"[..]; - /// assert_eq!(0x0809A0A1, buf.get_u32()); - /// ``` - /// - /// # Panics - /// - /// This function panics if there is not enough remaining data in `self`. - fn get_u32(&mut self) -> u32 { - buf_get_impl!(self, u32::from_be_bytes); - } - - /// Gets an unsigned 32 bit integer from `self` in the little-endian byte order. - /// - /// The current position is advanced by 4. - /// - /// # Examples - /// - /// ``` - /// use bytes::Buf; - /// - /// let mut buf = &b"\xA1\xA0\x09\x08 hello"[..]; - /// assert_eq!(0x0809A0A1, buf.get_u32_le()); - /// ``` - /// - /// # Panics - /// - /// This function panics if there is not enough remaining data in `self`. - fn get_u32_le(&mut self) -> u32 { - buf_get_impl!(self, u32::from_le_bytes); - } - - /// Gets 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. - /// - /// # Examples - /// - /// ``` - /// use bytes::Buf; - /// - /// let mut buf = &b"\x08\x09\xA0\xA1 hello"[..]; - /// assert_eq!(0x0809A0A1, buf.get_i32()); - /// ``` - /// - /// # Panics - /// - /// This function panics if there is not enough remaining data in `self`. - fn get_i32(&mut self) -> i32 { - buf_get_impl!(self, i32::from_be_bytes); - } - - /// Gets a signed 32 bit integer from `self` in little-endian byte order. - /// - /// The current position is advanced by 4. - /// - /// # Examples - /// - /// ``` - /// use bytes::Buf; - /// - /// let mut buf = &b"\xA1\xA0\x09\x08 hello"[..]; - /// assert_eq!(0x0809A0A1, buf.get_i32_le()); - /// ``` - /// - /// # Panics - /// - /// This function panics if there is not enough remaining data in `self`. - fn get_i32_le(&mut self) -> i32 { - buf_get_impl!(self, i32::from_le_bytes); - } - - /// Gets 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. - /// - /// # Examples - /// - /// ``` - /// use bytes::Buf; - /// - /// let mut buf = &b"\x01\x02\x03\x04\x05\x06\x07\x08 hello"[..]; - /// assert_eq!(0x0102030405060708, buf.get_u64()); - /// ``` - /// - /// # Panics - /// - /// This function panics if there is not enough remaining data in `self`. - fn get_u64(&mut self) -> u64 { - buf_get_impl!(self, u64::from_be_bytes); - } - - /// Gets an unsigned 64 bit integer from `self` in little-endian byte order. - /// - /// The current position is advanced by 8. - /// - /// # Examples - /// - /// ``` - /// use bytes::Buf; - /// - /// let mut buf = &b"\x08\x07\x06\x05\x04\x03\x02\x01 hello"[..]; - /// assert_eq!(0x0102030405060708, buf.get_u64_le()); - /// ``` - /// - /// # Panics - /// - /// This function panics if there is not enough remaining data in `self`. - fn get_u64_le(&mut self) -> u64 { - buf_get_impl!(self, u64::from_le_bytes); - } - - /// Gets 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. - /// - /// # Examples - /// - /// ``` - /// use bytes::Buf; - /// - /// let mut buf = &b"\x01\x02\x03\x04\x05\x06\x07\x08 hello"[..]; - /// assert_eq!(0x0102030405060708, buf.get_i64()); - /// ``` - /// - /// # Panics - /// - /// This function panics if there is not enough remaining data in `self`. - fn get_i64(&mut self) -> i64 { - buf_get_impl!(self, i64::from_be_bytes); - } - - /// Gets a signed 64 bit integer from `self` in little-endian byte order. - /// - /// The current position is advanced by 8. - /// - /// # Examples - /// - /// ``` - /// use bytes::Buf; - /// - /// let mut buf = &b"\x08\x07\x06\x05\x04\x03\x02\x01 hello"[..]; - /// assert_eq!(0x0102030405060708, buf.get_i64_le()); - /// ``` - /// - /// # Panics - /// - /// This function panics if there is not enough remaining data in `self`. - fn get_i64_le(&mut self) -> i64 { - buf_get_impl!(self, i64::from_le_bytes); - } - - /// Gets 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. - /// - /// # Examples - /// - /// ``` - /// use bytes::Buf; - /// - /// let mut buf = &b"\x01\x02\x03\x04\x05\x06\x07\x08\x09\x10\x11\x12\x13\x14\x15\x16 hello"[..]; - /// assert_eq!(0x01020304050607080910111213141516, buf.get_u128()); - /// ``` - /// - /// # Panics - /// - /// This function panics if there is not enough remaining data in `self`. - fn get_u128(&mut self) -> u128 { - buf_get_impl!(self, u128::from_be_bytes); - } - - /// Gets an unsigned 128 bit integer from `self` in little-endian byte order. - /// - /// The current position is advanced by 16. - /// - /// # Examples - /// - /// ``` - /// use bytes::Buf; - /// - /// let mut buf = &b"\x16\x15\x14\x13\x12\x11\x10\x09\x08\x07\x06\x05\x04\x03\x02\x01 hello"[..]; - /// assert_eq!(0x01020304050607080910111213141516, buf.get_u128_le()); - /// ``` - /// - /// # Panics - /// - /// This function panics if there is not enough remaining data in `self`. - fn get_u128_le(&mut self) -> u128 { - buf_get_impl!(self, u128::from_le_bytes); - } - - /// Gets 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. - /// - /// # Examples - /// - /// ``` - /// use bytes::Buf; - /// - /// let mut buf = &b"\x01\x02\x03\x04\x05\x06\x07\x08\x09\x10\x11\x12\x13\x14\x15\x16 hello"[..]; - /// assert_eq!(0x01020304050607080910111213141516, buf.get_i128()); - /// ``` - /// - /// # Panics - /// - /// This function panics if there is not enough remaining data in `self`. - fn get_i128(&mut self) -> i128 { - buf_get_impl!(self, i128::from_be_bytes); - } - - /// Gets a signed 128 bit integer from `self` in little-endian byte order. - /// - /// The current position is advanced by 16. - /// - /// # Examples - /// - /// ``` - /// use bytes::Buf; - /// - /// let mut buf = &b"\x16\x15\x14\x13\x12\x11\x10\x09\x08\x07\x06\x05\x04\x03\x02\x01 hello"[..]; - /// assert_eq!(0x01020304050607080910111213141516, buf.get_i128_le()); - /// ``` - /// - /// # Panics - /// - /// This function panics if there is not enough remaining data in `self`. - fn get_i128_le(&mut self) -> i128 { - buf_get_impl!(self, i128::from_le_bytes); - } - - /// Gets 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`. - /// - /// # Examples - /// - /// ``` - /// use bytes::Buf; - /// - /// let mut buf = &b"\x01\x02\x03 hello"[..]; - /// assert_eq!(0x010203, buf.get_uint(3)); - /// ``` - /// - /// # Panics - /// - /// This function panics if there is not enough remaining data in `self`, or - /// if `nbytes` is greater than 8. - fn get_uint(&mut self, nbytes: usize) -> u64 { - buf_get_impl!(be => self, u64, nbytes); - } - - /// Gets an unsigned n-byte integer from `self` in little-endian byte order. - /// - /// The current position is advanced by `nbytes`. - /// - /// # Examples - /// - /// ``` - /// use bytes::Buf; - /// - /// let mut buf = &b"\x03\x02\x01 hello"[..]; - /// assert_eq!(0x010203, buf.get_uint_le(3)); - /// ``` - /// - /// # Panics - /// - /// This function panics if there is not enough remaining data in `self`, or - /// if `nbytes` is greater than 8. - fn get_uint_le(&mut self, nbytes: usize) -> u64 { - 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`. - /// - /// # Examples - /// - /// ``` - /// use bytes::Buf; - /// - /// let mut buf = &b"\x01\x02\x03 hello"[..]; - /// assert_eq!(0x010203, buf.get_int(3)); - /// ``` - /// - /// # Panics - /// - /// This function panics if there is not enough remaining data in `self`, or - /// if `nbytes` is greater than 8. - fn get_int(&mut self, nbytes: usize) -> i64 { - sign_extend(self.get_uint(nbytes), nbytes) - } - - /// Gets a signed n-byte integer from `self` in little-endian byte order. - /// - /// The current position is advanced by `nbytes`. - /// - /// # Examples - /// - /// ``` - /// use bytes::Buf; - /// - /// let mut buf = &b"\x03\x02\x01 hello"[..]; - /// assert_eq!(0x010203, buf.get_int_le(3)); - /// ``` - /// - /// # Panics - /// - /// This function panics if there is not enough remaining data in `self`, or - /// if `nbytes` is greater than 8. - 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) - } - } - - /// Gets an IEEE754 single-precision (4 bytes) floating point number from - /// `self` in big-endian byte order. - /// - /// The current position is advanced by 4. - /// - /// # Examples - /// - /// ``` - /// use bytes::Buf; - /// - /// let mut buf = &b"\x3F\x99\x99\x9A hello"[..]; - /// assert_eq!(1.2f32, buf.get_f32()); - /// ``` - /// - /// # Panics - /// - /// This function panics if there is not enough remaining data in `self`. - fn get_f32(&mut self) -> f32 { - f32::from_bits(self.get_u32()) - } - - /// Gets an IEEE754 single-precision (4 bytes) floating point number from - /// `self` in little-endian byte order. - /// - /// The current position is advanced by 4. - /// - /// # Examples - /// - /// ``` - /// use bytes::Buf; - /// - /// let mut buf = &b"\x9A\x99\x99\x3F hello"[..]; - /// assert_eq!(1.2f32, buf.get_f32_le()); - /// ``` - /// - /// # Panics - /// - /// This function panics if there is not enough remaining data in `self`. - fn get_f32_le(&mut self) -> f32 { - f32::from_bits(self.get_u32_le()) - } - - /// 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()) - } - - /// Gets an IEEE754 double-precision (8 bytes) floating point number from - /// `self` in big-endian byte order. - /// - /// The current position is advanced by 8. - /// - /// # Examples - /// - /// ``` - /// use bytes::Buf; - /// - /// let mut buf = &b"\x3F\xF3\x33\x33\x33\x33\x33\x33 hello"[..]; - /// assert_eq!(1.2f64, buf.get_f64()); - /// ``` - /// - /// # Panics - /// - /// This function panics if there is not enough remaining data in `self`. - fn get_f64(&mut self) -> f64 { - f64::from_bits(self.get_u64()) - } - - /// Gets an IEEE754 double-precision (8 bytes) floating point number from - /// `self` in little-endian byte order. - /// - /// The current position is advanced by 8. - /// - /// # Examples - /// - /// ``` - /// use bytes::Buf; - /// - /// let mut buf = &b"\x33\x33\x33\x33\x33\x33\xF3\x3F hello"[..]; - /// assert_eq!(1.2f64, buf.get_f64_le()); - /// ``` - /// - /// # Panics - /// - /// This function panics if there is not enough remaining data in `self`. - fn get_f64_le(&mut self) -> f64 { - f64::from_bits(self.get_u64_le()) - } - - /// 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()) - } - - /// Copies bytes from `self` into `dst`. - /// - /// The cursor is advanced by the number of bytes copied. `self` must have - /// enough remaining bytes to fill `dst`. - /// - /// Returns `Err(TryGetError)` when there are not enough - /// remaining bytes to read the value. - /// - /// # Examples - /// - /// ``` - /// use bytes::Buf; - /// - /// let mut buf = &b"hello world"[..]; - /// let mut dst = [0; 5]; - /// - /// assert_eq!(Ok(()), buf.try_copy_to_slice(&mut dst)); - /// assert_eq!(&b"hello"[..], &dst); - /// assert_eq!(6, buf.remaining()); - /// ``` - /// - /// ``` - /// use bytes::{Buf, TryGetError}; - /// - /// let mut buf = &b"hello world"[..]; - /// let mut dst = [0; 12]; - /// - /// assert_eq!(Err(TryGetError{requested: 12, available: 11}), buf.try_copy_to_slice(&mut dst)); - /// assert_eq!(11, buf.remaining()); - /// ``` - fn try_copy_to_slice(&mut self, mut dst: &mut [u8]) -> Result<(), TryGetError> { - if self.remaining() < dst.len() { - return Err(TryGetError { - requested: dst.len(), - available: self.remaining(), - }); - } - - while !dst.is_empty() { - let src = self.chunk(); - let cnt = usize::min(src.len(), dst.len()); - - dst[..cnt].copy_from_slice(&src[..cnt]); - dst = &mut dst[cnt..]; - - self.advance(cnt); - } - Ok(()) - } - - /// Gets an unsigned 8 bit integer from `self`. - /// - /// The current position is advanced by 1. - /// - /// Returns `Err(TryGetError)` when there are not enough - /// remaining bytes to read the value. - /// - /// # Examples - /// - /// ``` - /// use bytes::Buf; - /// - /// let mut buf = &b"\x08 hello"[..]; - /// assert_eq!(Ok(0x08_u8), buf.try_get_u8()); - /// assert_eq!(6, buf.remaining()); - /// ``` - /// - /// ``` - /// use bytes::{Buf, TryGetError}; - /// - /// let mut buf = &b""[..]; - /// assert_eq!(Err(TryGetError{requested: 1, available: 0}), buf.try_get_u8()); - /// ``` - fn try_get_u8(&mut self) -> Result<u8, TryGetError> { - if self.remaining() < 1 { - return Err(TryGetError { - requested: 1, - available: self.remaining(), - }); - } - let ret = self.chunk()[0]; - self.advance(1); - Ok(ret) - } - - /// Gets a signed 8 bit integer from `self`. - /// - /// The current position is advanced by 1. - /// - /// Returns `Err(TryGetError)` when there are not enough - /// remaining bytes to read the value. - /// - /// # Examples - /// - /// ``` - /// use bytes::Buf; - /// - /// let mut buf = &b"\x08 hello"[..]; - /// assert_eq!(Ok(0x08_i8), buf.try_get_i8()); - /// assert_eq!(6, buf.remaining()); - /// ``` - /// - /// ``` - /// use bytes::{Buf, TryGetError}; - /// - /// let mut buf = &b""[..]; - /// assert_eq!(Err(TryGetError{requested: 1, available: 0}), buf.try_get_i8()); - /// ``` - fn try_get_i8(&mut self) -> Result<i8, TryGetError> { - if self.remaining() < 1 { - return Err(TryGetError { - requested: 1, - available: self.remaining(), - }); - } - let ret = self.chunk()[0] as i8; - self.advance(1); - Ok(ret) - } - - /// Gets an unsigned 16 bit integer from `self` in big-endian byte order. - /// - /// The current position is advanced by 2. - /// - /// Returns `Err(TryGetError)` when there are not enough - /// remaining bytes to read the value. - /// - /// # Examples - /// - /// ``` - /// use bytes::Buf; - /// - /// let mut buf = &b"\x08\x09 hello"[..]; - /// assert_eq!(Ok(0x0809_u16), buf.try_get_u16()); - /// assert_eq!(6, buf.remaining()); - /// ``` - /// - /// ``` - /// use bytes::{Buf, TryGetError}; - /// - /// let mut buf = &b"\x08"[..]; - /// assert_eq!(Err(TryGetError{requested: 2, available: 1}), buf.try_get_u16()); - /// assert_eq!(1, buf.remaining()); - /// ``` - fn try_get_u16(&mut self) -> Result<u16, TryGetError> { - buf_try_get_impl!(self, u16::from_be_bytes) - } - - /// Gets an unsigned 16 bit integer from `self` in little-endian byte order. - /// - /// The current position is advanced by 2. - /// - /// Returns `Err(TryGetError)` when there are not enough - /// remaining bytes to read the value. - /// - /// # Examples - /// - /// ``` - /// use bytes::Buf; - /// - /// let mut buf = &b"\x09\x08 hello"[..]; - /// assert_eq!(Ok(0x0809_u16), buf.try_get_u16_le()); - /// assert_eq!(6, buf.remaining()); - /// ``` - /// - /// ``` - /// use bytes::{Buf, TryGetError}; - /// - /// let mut buf = &b"\x08"[..]; - /// assert_eq!(Err(TryGetError{requested: 2, available: 1}), buf.try_get_u16_le()); - /// assert_eq!(1, buf.remaining()); - /// ``` - fn try_get_u16_le(&mut self) -> Result<u16, TryGetError> { - buf_try_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. - /// - /// Returns `Err(TryGetError)` when there are not enough - /// remaining bytes to read the value. - /// - /// # 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!(Ok(0x0809_u16), buf.try_get_u16_ne()); - /// assert_eq!(6, buf.remaining()); - /// ``` - /// - /// ``` - /// use bytes::{Buf, TryGetError}; - /// - /// let mut buf = &b"\x08"[..]; - /// assert_eq!(Err(TryGetError{requested: 2, available: 1}), buf.try_get_u16_ne()); - /// assert_eq!(1, buf.remaining()); - /// ``` - fn try_get_u16_ne(&mut self) -> Result<u16, TryGetError> { - buf_try_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. - /// - /// Returns `Err(TryGetError)` when there are not enough - /// remaining bytes to read the value. - /// - /// # Examples - /// - /// ``` - /// use bytes::Buf; - /// - /// let mut buf = &b"\x08\x09 hello"[..]; - /// assert_eq!(Ok(0x0809_i16), buf.try_get_i16()); - /// assert_eq!(6, buf.remaining()); - /// ``` - /// - /// ``` - /// use bytes::{Buf, TryGetError}; - /// - /// let mut buf = &b"\x08"[..]; - /// assert_eq!(Err(TryGetError{requested: 2, available: 1}), buf.try_get_i16()); - /// assert_eq!(1, buf.remaining()); - /// ``` - fn try_get_i16(&mut self) -> Result<i16, TryGetError> { - buf_try_get_impl!(self, i16::from_be_bytes) - } - - /// Gets an signed 16 bit integer from `self` in little-endian byte order. - /// - /// The current position is advanced by 2. - /// - /// Returns `Err(TryGetError)` when there are not enough - /// remaining bytes to read the value. - /// - /// # Examples - /// - /// ``` - /// use bytes::Buf; - /// - /// let mut buf = &b"\x09\x08 hello"[..]; - /// assert_eq!(Ok(0x0809_i16), buf.try_get_i16_le()); - /// assert_eq!(6, buf.remaining()); - /// ``` - /// - /// ``` - /// use bytes::{Buf, TryGetError}; - /// - /// let mut buf = &b"\x08"[..]; - /// assert_eq!(Err(TryGetError{requested: 2, available: 1}), buf.try_get_i16_le()); - /// assert_eq!(1, buf.remaining()); - /// ``` - fn try_get_i16_le(&mut self) -> Result<i16, TryGetError> { - buf_try_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. - /// - /// Returns `Err(TryGetError)` when there are not enough - /// remaining bytes to read the value. - /// - /// # 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!(Ok(0x0809_i16), buf.try_get_i16_ne()); - /// assert_eq!(6, buf.remaining()); - /// ``` - /// - /// ``` - /// use bytes::{Buf, TryGetError}; - /// - /// let mut buf = &b"\x08"[..]; - /// assert_eq!(Err(TryGetError{requested: 2, available: 1}), buf.try_get_i16_ne()); - /// assert_eq!(1, buf.remaining()); - /// ``` - fn try_get_i16_ne(&mut self) -> Result<i16, TryGetError> { - buf_try_get_impl!(self, i16::from_ne_bytes) - } - - /// Gets an unsigned 32 bit integer from `self` in big-endian byte order. - /// - /// The current position is advanced by 4. - /// - /// Returns `Err(TryGetError)` when there are not enough - /// remaining bytes to read the value. - /// - /// # Examples - /// - /// ``` - /// use bytes::Buf; - /// - /// let mut buf = &b"\x08\x09\xA0\xA1 hello"[..]; - /// assert_eq!(Ok(0x0809A0A1), buf.try_get_u32()); - /// assert_eq!(6, buf.remaining()); - /// ``` - /// - /// ``` - /// use bytes::{Buf, TryGetError}; - /// - /// let mut buf = &b"\x01\x02\x03"[..]; - /// assert_eq!(Err(TryGetError{requested: 4, available: 3}), buf.try_get_u32()); - /// assert_eq!(3, buf.remaining()); - /// ``` - fn try_get_u32(&mut self) -> Result<u32, TryGetError> { - buf_try_get_impl!(self, u32::from_be_bytes) - } - - /// Gets an unsigned 32 bit integer from `self` in little-endian byte order. - /// - /// The current position is advanced by 4. - /// - /// Returns `Err(TryGetError)` when there are not enough - /// remaining bytes to read the value. - /// - /// # Examples - /// - /// ``` - /// use bytes::Buf; - /// - /// let mut buf = &b"\xA1\xA0\x09\x08 hello"[..]; - /// assert_eq!(Ok(0x0809A0A1_u32), buf.try_get_u32_le()); - /// assert_eq!(6, buf.remaining()); - /// ``` - /// - /// ``` - /// use bytes::{Buf, TryGetError}; - /// - /// let mut buf = &b"\x08\x09\xA0"[..]; - /// assert_eq!(Err(TryGetError{requested: 4, available: 3}), buf.try_get_u32_le()); - /// assert_eq!(3, buf.remaining()); - /// ``` - fn try_get_u32_le(&mut self) -> Result<u32, TryGetError> { - buf_try_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. - /// - /// Returns `Err(TryGetError)` when there are not enough - /// remaining bytes to read the value. - /// - /// # 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!(Ok(0x0809A0A1_u32), buf.try_get_u32_ne()); - /// assert_eq!(6, buf.remaining()); - /// ``` - /// - /// ``` - /// use bytes::{Buf, TryGetError}; - /// - /// let mut buf = &b"\x08\x09\xA0"[..]; - /// assert_eq!(Err(TryGetError{requested: 4, available: 3}), buf.try_get_u32_ne()); - /// assert_eq!(3, buf.remaining()); - /// ``` - fn try_get_u32_ne(&mut self) -> Result<u32, TryGetError> { - buf_try_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. - /// - /// Returns `Err(TryGetError)` when there are not enough - /// remaining bytes to read the value. - /// - /// # Examples - /// - /// ``` - /// use bytes::Buf; - /// - /// let mut buf = &b"\x08\x09\xA0\xA1 hello"[..]; - /// assert_eq!(Ok(0x0809A0A1_i32), buf.try_get_i32()); - /// assert_eq!(6, buf.remaining()); - /// ``` - /// - /// ``` - /// use bytes::{Buf, TryGetError}; - /// - /// let mut buf = &b"\x01\x02\x03"[..]; - /// assert_eq!(Err(TryGetError{requested: 4, available: 3}), buf.try_get_i32()); - /// assert_eq!(3, buf.remaining()); - /// ``` - fn try_get_i32(&mut self) -> Result<i32, TryGetError> { - buf_try_get_impl!(self, i32::from_be_bytes) - } - - /// Gets a signed 32 bit integer from `self` in little-endian byte order. - /// - /// The current position is advanced by 4. - /// - /// Returns `Err(TryGetError)` when there are not enough - /// remaining bytes to read the value. - /// - /// # Examples - /// - /// ``` - /// use bytes::Buf; - /// - /// let mut buf = &b"\xA1\xA0\x09\x08 hello"[..]; - /// assert_eq!(Ok(0x0809A0A1_i32), buf.try_get_i32_le()); - /// assert_eq!(6, buf.remaining()); - /// ``` - /// - /// ``` - /// use bytes::{Buf, TryGetError}; - /// - /// let mut buf = &b"\x08\x09\xA0"[..]; - /// assert_eq!(Err(TryGetError{requested: 4, available: 3}), buf.try_get_i32_le()); - /// assert_eq!(3, buf.remaining()); - /// ``` - fn try_get_i32_le(&mut self) -> Result<i32, TryGetError> { - buf_try_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. - /// - /// Returns `Err(TryGetError)` when there are not enough - /// remaining bytes to read the value. - /// - /// # 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!(Ok(0x0809A0A1_i32), buf.try_get_i32_ne()); - /// assert_eq!(6, buf.remaining()); - /// ``` - /// - /// ``` - /// use bytes::{Buf, TryGetError}; - /// - /// let mut buf = &b"\x08\x09\xA0"[..]; - /// assert_eq!(Err(TryGetError{requested: 4, available: 3}), buf.try_get_i32_ne()); - /// assert_eq!(3, buf.remaining()); - /// ``` - fn try_get_i32_ne(&mut self) -> Result<i32, TryGetError> { - buf_try_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. - /// - /// Returns `Err(TryGetError)` when there are not enough - /// remaining bytes to read the value. - /// - /// # Examples - /// - /// ``` - /// use bytes::Buf; - /// - /// let mut buf = &b"\x01\x02\x03\x04\x05\x06\x07\x08 hello"[..]; - /// assert_eq!(Ok(0x0102030405060708_u64), buf.try_get_u64()); - /// assert_eq!(6, buf.remaining()); - /// ``` - /// - /// ``` - /// use bytes::{Buf, TryGetError}; - /// - /// let mut buf = &b"\x01\x02\x03\x04\x05\x06\x07"[..]; - /// assert_eq!(Err(TryGetError{requested: 8, available: 7}), buf.try_get_u64()); - /// assert_eq!(7, buf.remaining()); - /// ``` - fn try_get_u64(&mut self) -> Result<u64, TryGetError> { - buf_try_get_impl!(self, u64::from_be_bytes) - } - - /// Gets an unsigned 64 bit integer from `self` in little-endian byte order. - /// - /// The current position is advanced by 8. - /// - /// Returns `Err(TryGetError)` when there are not enough - /// remaining bytes to read the value. - /// - /// # Examples - /// - /// ``` - /// use bytes::Buf; - /// - /// let mut buf = &b"\x08\x07\x06\x05\x04\x03\x02\x01 hello"[..]; - /// assert_eq!(Ok(0x0102030405060708_u64), buf.try_get_u64_le()); - /// assert_eq!(6, buf.remaining()); - /// ``` - /// - /// ``` - /// use bytes::{Buf, TryGetError}; - /// - /// let mut buf = &b"\x08\x07\x06\x05\x04\x03\x02"[..]; - /// assert_eq!(Err(TryGetError{requested: 8, available: 7}), buf.try_get_u64_le()); - /// assert_eq!(7, buf.remaining()); - /// ``` - fn try_get_u64_le(&mut self) -> Result<u64, TryGetError> { - buf_try_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. - /// - /// Returns `Err(TryGetError)` when there are not enough - /// remaining bytes to read the value. - /// - /// # 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!(Ok(0x0102030405060708_u64), buf.try_get_u64_ne()); - /// assert_eq!(6, buf.remaining()); - /// ``` - /// - /// ``` - /// use bytes::{Buf, TryGetError}; - /// - /// let mut buf = &b"\x01\x02\x03\x04\x05\x06\x07"[..]; - /// assert_eq!(Err(TryGetError{requested: 8, available: 7}), buf.try_get_u64_ne()); - /// assert_eq!(7, buf.remaining()); - /// ``` - fn try_get_u64_ne(&mut self) -> Result<u64, TryGetError> { - buf_try_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. - /// - /// Returns `Err(TryGetError)` when there are not enough - /// remaining bytes to read the value. - /// - /// # Examples - /// - /// ``` - /// use bytes::Buf; - /// - /// let mut buf = &b"\x01\x02\x03\x04\x05\x06\x07\x08 hello"[..]; - /// assert_eq!(Ok(0x0102030405060708_i64), buf.try_get_i64()); - /// assert_eq!(6, buf.remaining()); - /// ``` - /// - /// ``` - /// use bytes::{Buf, TryGetError}; - /// - /// let mut buf = &b"\x01\x02\x03\x04\x05\x06\x07"[..]; - /// assert_eq!(Err(TryGetError{requested: 8, available: 7}), buf.try_get_i64()); - /// assert_eq!(7, buf.remaining()); - /// ``` - fn try_get_i64(&mut self) -> Result<i64, TryGetError> { - buf_try_get_impl!(self, i64::from_be_bytes) - } - - /// Gets a signed 64 bit integer from `self` in little-endian byte order. - /// - /// The current position is advanced by 8. - /// - /// Returns `Err(TryGetError)` when there are not enough - /// remaining bytes to read the value. - /// - /// # Examples - /// - /// ``` - /// use bytes::Buf; - /// - /// let mut buf = &b"\x08\x07\x06\x05\x04\x03\x02\x01 hello"[..]; - /// assert_eq!(Ok(0x0102030405060708_i64), buf.try_get_i64_le()); - /// assert_eq!(6, buf.remaining()); - /// ``` - /// - /// ``` - /// use bytes::{Buf, TryGetError}; - /// - /// let mut buf = &b"\x08\x07\x06\x05\x04\x03\x02"[..]; - /// assert_eq!(Err(TryGetError{requested: 8, available: 7}), buf.try_get_i64_le()); - /// assert_eq!(7, buf.remaining()); - /// ``` - fn try_get_i64_le(&mut self) -> Result<i64, TryGetError> { - buf_try_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. - /// - /// Returns `Err(TryGetError)` when there are not enough - /// remaining bytes to read the value. - /// - /// # 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!(Ok(0x0102030405060708_i64), buf.try_get_i64_ne()); - /// assert_eq!(6, buf.remaining()); - /// ``` - /// - /// ``` - /// use bytes::{Buf, TryGetError}; - /// - /// let mut buf = &b"\x01\x02\x03\x04\x05\x06\x07"[..]; - /// assert_eq!(Err(TryGetError{requested: 8, available: 7}), buf.try_get_i64_ne()); - /// assert_eq!(7, buf.remaining()); - /// ``` - fn try_get_i64_ne(&mut self) -> Result<i64, TryGetError> { - buf_try_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. - /// - /// Returns `Err(TryGetError)` when there are not enough - /// remaining bytes to read the value. - /// - /// # Examples - /// - /// ``` - /// use bytes::Buf; - /// - /// let mut buf = &b"\x01\x02\x03\x04\x05\x06\x07\x08\x09\x10\x11\x12\x13\x14\x15\x16 hello"[..]; - /// assert_eq!(Ok(0x01020304050607080910111213141516_u128), buf.try_get_u128()); - /// assert_eq!(6, buf.remaining()); - /// ``` - /// - /// ``` - /// use bytes::{Buf, TryGetError}; - /// - /// let mut buf = &b"\x01\x02\x03\x04\x05\x06\x07\x08\x09\x10\x11\x12\x13\x14\x15"[..]; - /// assert_eq!(Err(TryGetError{requested: 16, available: 15}), buf.try_get_u128()); - /// assert_eq!(15, buf.remaining()); - /// ``` - fn try_get_u128(&mut self) -> Result<u128, TryGetError> { - buf_try_get_impl!(self, u128::from_be_bytes) - } - - /// Gets an unsigned 128 bit integer from `self` in little-endian byte order. - /// - /// The current position is advanced by 16. - /// - /// Returns `Err(TryGetError)` when there are not enough - /// remaining bytes to read the value. - /// - /// # Examples - /// - /// ``` - /// use bytes::Buf; - /// - /// let mut buf = &b"\x16\x15\x14\x13\x12\x11\x10\x09\x08\x07\x06\x05\x04\x03\x02\x01 hello"[..]; - /// assert_eq!(Ok(0x01020304050607080910111213141516_u128), buf.try_get_u128_le()); - /// assert_eq!(6, buf.remaining()); - /// ``` - /// - /// ``` - /// use bytes::{Buf, TryGetError}; - /// - /// let mut buf = &b"\x16\x15\x14\x13\x12\x11\x10\x09\x08\x07\x06\x05\x04\x03\x02"[..]; - /// assert_eq!(Err(TryGetError{requested: 16, available: 15}), buf.try_get_u128_le()); - /// assert_eq!(15, buf.remaining()); - /// ``` - fn try_get_u128_le(&mut self) -> Result<u128, TryGetError> { - buf_try_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. - /// - /// Returns `Err(TryGetError)` when there are not enough - /// remaining bytes to read the value. - /// - /// # 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!(Ok(0x01020304050607080910111213141516_u128), buf.try_get_u128_ne()); - /// assert_eq!(6, buf.remaining()); - /// ``` - /// - /// ``` - /// use bytes::{Buf, TryGetError}; - /// - /// let mut buf = &b"\x01\x02\x03\x04\x05\x06\x07\x08\x09\x10\x11\x12\x13\x14\x15"[..]; - /// assert_eq!(Err(TryGetError{requested: 16, available: 15}), buf.try_get_u128_ne()); - /// assert_eq!(15, buf.remaining()); - /// ``` - fn try_get_u128_ne(&mut self) -> Result<u128, TryGetError> { - buf_try_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. - /// - /// Returns `Err(TryGetError)` when there are not enough - /// remaining bytes to read the value. - /// - /// # Examples - /// - /// ``` - /// use bytes::Buf; - /// - /// let mut buf = &b"\x01\x02\x03\x04\x05\x06\x07\x08\x09\x10\x11\x12\x13\x14\x15\x16 hello"[..]; - /// assert_eq!(Ok(0x01020304050607080910111213141516_i128), buf.try_get_i128()); - /// assert_eq!(6, buf.remaining()); - /// ``` - /// - /// ``` - /// use bytes::{Buf, TryGetError}; - /// - /// let mut buf = &b"\x01\x02\x03\x04\x05\x06\x07\x08\x09\x10\x11\x12\x13\x14\x15"[..]; - /// assert_eq!(Err(TryGetError{requested: 16, available: 15}), buf.try_get_i128()); - /// assert_eq!(15, buf.remaining()); - /// ``` - fn try_get_i128(&mut self) -> Result<i128, TryGetError> { - buf_try_get_impl!(self, i128::from_be_bytes) - } - - /// Gets a signed 128 bit integer from `self` in little-endian byte order. - /// - /// The current position is advanced by 16. - /// - /// Returns `Err(TryGetError)` when there are not enough - /// remaining bytes to read the value. - /// - /// # Examples - /// - /// ``` - /// use bytes::Buf; - /// - /// let mut buf = &b"\x16\x15\x14\x13\x12\x11\x10\x09\x08\x07\x06\x05\x04\x03\x02\x01 hello"[..]; - /// assert_eq!(Ok(0x01020304050607080910111213141516_i128), buf.try_get_i128_le()); - /// assert_eq!(6, buf.remaining()); - /// ``` - /// - /// ``` - /// use bytes::{Buf, TryGetError}; - /// - /// let mut buf = &b"\x16\x15\x14\x13\x12\x11\x10\x09\x08\x07\x06\x05\x04\x03\x02"[..]; - /// assert_eq!(Err(TryGetError{requested: 16, available: 15}), buf.try_get_i128_le()); - /// assert_eq!(15, buf.remaining()); - /// ``` - fn try_get_i128_le(&mut self) -> Result<i128, TryGetError> { - buf_try_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. - /// - /// Returns `Err(TryGetError)` when there are not enough - /// remaining bytes to read the value. - /// - /// # 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!(Ok(0x01020304050607080910111213141516_i128), buf.try_get_i128_ne()); - /// assert_eq!(6, buf.remaining()); - /// ``` - /// - /// ``` - /// use bytes::{Buf, TryGetError}; - /// - /// let mut buf = &b"\x01\x02\x03\x04\x05\x06\x07\x08\x09\x10\x11\x12\x13\x14\x15"[..]; - /// assert_eq!(Err(TryGetError{requested: 16, available: 15}), buf.try_get_i128_ne()); - /// assert_eq!(15, buf.remaining()); - /// ``` - fn try_get_i128_ne(&mut self) -> Result<i128, TryGetError> { - buf_try_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`. - /// - /// Returns `Err(TryGetError)` when there are not enough - /// remaining bytes to read the value. - /// - /// # Examples - /// - /// ``` - /// use bytes::Buf; - /// - /// let mut buf = &b"\x01\x02\x03 hello"[..]; - /// assert_eq!(Ok(0x010203_u64), buf.try_get_uint(3)); - /// assert_eq!(6, buf.remaining()); - /// ``` - /// - /// ``` - /// use bytes::{Buf, TryGetError}; - /// - /// let mut buf = &b"\x01\x02\x03"[..]; - /// assert_eq!(Err(TryGetError{requested: 4, available: 3}), buf.try_get_uint(4)); - /// assert_eq!(3, buf.remaining()); - /// ``` - /// - /// # Panics - /// - /// This function panics if `nbytes` > 8. - fn try_get_uint(&mut self, nbytes: usize) -> Result<u64, TryGetError> { - buf_try_get_impl!(be => self, u64, nbytes); - } - - /// Gets an unsigned n-byte integer from `self` in little-endian byte order. - /// - /// The current position is advanced by `nbytes`. - /// - /// Returns `Err(TryGetError)` when there are not enough - /// remaining bytes to read the value. - /// - /// # Examples - /// - /// ``` - /// use bytes::Buf; - /// - /// let mut buf = &b"\x03\x02\x01 hello"[..]; - /// assert_eq!(Ok(0x010203_u64), buf.try_get_uint_le(3)); - /// assert_eq!(6, buf.remaining()); - /// ``` - /// - /// ``` - /// use bytes::{Buf, TryGetError}; - /// - /// let mut buf = &b"\x01\x02\x03"[..]; - /// assert_eq!(Err(TryGetError{requested: 4, available: 3}), buf.try_get_uint_le(4)); - /// assert_eq!(3, buf.remaining()); - /// ``` - /// - /// # Panics - /// - /// This function panics if `nbytes` > 8. - fn try_get_uint_le(&mut self, nbytes: usize) -> Result<u64, TryGetError> { - buf_try_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`. - /// - /// Returns `Err(TryGetError)` when there are not enough - /// remaining bytes to read the value. - /// - /// # 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!(Ok(0x010203_u64), buf.try_get_uint_ne(3)); - /// assert_eq!(6, buf.remaining()); - /// ``` - /// - /// ``` - /// use bytes::{Buf, TryGetError}; - /// - /// let mut buf: &[u8] = match cfg!(target_endian = "big") { - /// true => b"\x01\x02\x03", - /// false => b"\x03\x02\x01", - /// }; - /// assert_eq!(Err(TryGetError{requested: 4, available: 3}), buf.try_get_uint_ne(4)); - /// assert_eq!(3, buf.remaining()); - /// ``` - /// - /// # Panics - /// - /// This function panics if `nbytes` is greater than 8. - fn try_get_uint_ne(&mut self, nbytes: usize) -> Result<u64, TryGetError> { - if cfg!(target_endian = "big") { - self.try_get_uint(nbytes) - } else { - self.try_get_uint_le(nbytes) - } - } - - /// Gets a signed n-byte integer from `self` in big-endian byte order. - /// - /// The current position is advanced by `nbytes`. - /// - /// Returns `Err(TryGetError)` when there are not enough - /// remaining bytes to read the value. - /// - /// # Examples - /// - /// ``` - /// use bytes::Buf; - /// - /// let mut buf = &b"\x01\x02\x03 hello"[..]; - /// assert_eq!(Ok(0x010203_i64), buf.try_get_int(3)); - /// assert_eq!(6, buf.remaining()); - /// ``` - /// - /// ``` - /// use bytes::{Buf, TryGetError}; - /// - /// let mut buf = &b"\x01\x02\x03"[..]; - /// assert_eq!(Err(TryGetError{requested: 4, available: 3}), buf.try_get_int(4)); - /// assert_eq!(3, buf.remaining()); - /// ``` - /// - /// # Panics - /// - /// This function panics if `nbytes` is greater than 8. - fn try_get_int(&mut self, nbytes: usize) -> Result<i64, TryGetError> { - buf_try_get_impl!(be => self, i64, nbytes); - } - - /// Gets a signed n-byte integer from `self` in little-endian byte order. - /// - /// The current position is advanced by `nbytes`. - /// - /// Returns `Err(TryGetError)` when there are not enough - /// remaining bytes to read the value. - /// - /// # Examples - /// - /// ``` - /// use bytes::Buf; - /// - /// let mut buf = &b"\x03\x02\x01 hello"[..]; - /// assert_eq!(Ok(0x010203_i64), buf.try_get_int_le(3)); - /// assert_eq!(6, buf.remaining()); - /// ``` - /// - /// ``` - /// use bytes::{Buf, TryGetError}; - /// - /// let mut buf = &b"\x01\x02\x03"[..]; - /// assert_eq!(Err(TryGetError{requested: 4, available: 3}), buf.try_get_int_le(4)); - /// assert_eq!(3, buf.remaining()); - /// ``` - /// - /// # Panics - /// - /// This function panics if `nbytes` is greater than 8. - fn try_get_int_le(&mut self, nbytes: usize) -> Result<i64, TryGetError> { - buf_try_get_impl!(le => self, i64, nbytes); - } - - /// Gets a signed n-byte integer from `self` in native-endian byte order. - /// - /// The current position is advanced by `nbytes`. - /// - /// Returns `Err(TryGetError)` when there are not enough - /// remaining bytes to read the value. - /// - /// # 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!(Ok(0x010203_i64), buf.try_get_int_ne(3)); - /// assert_eq!(6, buf.remaining()); - /// ``` - /// - /// ``` - /// use bytes::{Buf, TryGetError}; - /// - /// let mut buf: &[u8] = match cfg!(target_endian = "big") { - /// true => b"\x01\x02\x03", - /// false => b"\x03\x02\x01", - /// }; - /// assert_eq!(Err(TryGetError{requested: 4, available: 3}), buf.try_get_int_ne(4)); - /// assert_eq!(3, buf.remaining()); - /// ``` - /// - /// # Panics - /// - /// This function panics if `nbytes` is greater than 8. - fn try_get_int_ne(&mut self, nbytes: usize) -> Result<i64, TryGetError> { - if cfg!(target_endian = "big") { - self.try_get_int(nbytes) - } else { - self.try_get_int_le(nbytes) - } - } - - /// Gets an IEEE754 single-precision (4 bytes) floating point number from - /// `self` in big-endian byte order. - /// - /// The current position is advanced by 4. - /// - /// Returns `Err(TryGetError)` when there are not enough - /// remaining bytes to read the value. - /// - /// # Examples - /// - /// ``` - /// use bytes::Buf; - /// - /// let mut buf = &b"\x3F\x99\x99\x9A hello"[..]; - /// assert_eq!(1.2f32, buf.get_f32()); - /// assert_eq!(6, buf.remaining()); - /// ``` - /// - /// ``` - /// use bytes::{Buf, TryGetError}; - /// - /// let mut buf = &b"\x3F\x99\x99"[..]; - /// assert_eq!(Err(TryGetError{requested: 4, available: 3}), buf.try_get_f32()); - /// assert_eq!(3, buf.remaining()); - /// ``` - fn try_get_f32(&mut self) -> Result<f32, TryGetError> { - Ok(f32::from_bits(self.try_get_u32()?)) - } - - /// Gets an IEEE754 single-precision (4 bytes) floating point number from - /// `self` in little-endian byte order. - /// - /// The current position is advanced by 4. - /// - /// Returns `Err(TryGetError)` when there are not enough - /// remaining bytes to read the value. - /// - /// # Examples - /// - /// ``` - /// use bytes::Buf; - /// - /// let mut buf = &b"\x9A\x99\x99\x3F hello"[..]; - /// assert_eq!(1.2f32, buf.get_f32_le()); - /// assert_eq!(6, buf.remaining()); - /// ``` - /// - /// ``` - /// use bytes::{Buf, TryGetError}; - /// - /// let mut buf = &b"\x3F\x99\x99"[..]; - /// assert_eq!(Err(TryGetError{requested: 4, available: 3}), buf.try_get_f32_le()); - /// assert_eq!(3, buf.remaining()); - /// ``` - fn try_get_f32_le(&mut self) -> Result<f32, TryGetError> { - Ok(f32::from_bits(self.try_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. - /// - /// Returns `Err(TryGetError)` when there are not enough - /// remaining bytes to read the value. - /// - /// # 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()); - /// assert_eq!(6, buf.remaining()); - /// ``` - /// - /// ``` - /// use bytes::{Buf, TryGetError}; - /// - /// let mut buf = &b"\x3F\x99\x99"[..]; - /// assert_eq!(Err(TryGetError{requested: 4, available: 3}), buf.try_get_f32_ne()); - /// assert_eq!(3, buf.remaining()); - /// ``` - fn try_get_f32_ne(&mut self) -> Result<f32, TryGetError> { - Ok(f32::from_bits(self.try_get_u32_ne()?)) - } - - /// Gets an IEEE754 double-precision (8 bytes) floating point number from - /// `self` in big-endian byte order. - /// - /// The current position is advanced by 8. - /// - /// Returns `Err(TryGetError)` when there are not enough - /// remaining bytes to read the value. - /// - /// # Examples - /// - /// ``` - /// use bytes::Buf; - /// - /// let mut buf = &b"\x3F\xF3\x33\x33\x33\x33\x33\x33 hello"[..]; - /// assert_eq!(1.2f64, buf.get_f64()); - /// assert_eq!(6, buf.remaining()); - /// ``` - /// - /// ``` - /// use bytes::{Buf, TryGetError}; - /// - /// let mut buf = &b"\x3F\xF3\x33\x33\x33\x33\x33"[..]; - /// assert_eq!(Err(TryGetError{requested: 8, available: 7}), buf.try_get_f64()); - /// assert_eq!(7, buf.remaining()); - /// ``` - fn try_get_f64(&mut self) -> Result<f64, TryGetError> { - Ok(f64::from_bits(self.try_get_u64()?)) - } - - /// Gets an IEEE754 double-precision (8 bytes) floating point number from - /// `self` in little-endian byte order. - /// - /// The current position is advanced by 8. - /// - /// Returns `Err(TryGetError)` when there are not enough - /// remaining bytes to read the value. - /// - /// # Examples - /// - /// ``` - /// use bytes::Buf; - /// - /// let mut buf = &b"\x33\x33\x33\x33\x33\x33\xF3\x3F hello"[..]; - /// assert_eq!(1.2f64, buf.get_f64_le()); - /// assert_eq!(6, buf.remaining()); - /// ``` - /// - /// ``` - /// use bytes::{Buf, TryGetError}; - /// - /// let mut buf = &b"\x3F\xF3\x33\x33\x33\x33\x33"[..]; - /// assert_eq!(Err(TryGetError{requested: 8, available: 7}), buf.try_get_f64_le()); - /// assert_eq!(7, buf.remaining()); - /// ``` - fn try_get_f64_le(&mut self) -> Result<f64, TryGetError> { - Ok(f64::from_bits(self.try_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. - /// - /// Returns `Err(TryGetError)` when there are not enough - /// remaining bytes to read the value. - /// - /// # 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()); - /// assert_eq!(6, buf.remaining()); - /// ``` - /// - /// ``` - /// use bytes::{Buf, TryGetError}; - /// - /// let mut buf = &b"\x3F\xF3\x33\x33\x33\x33\x33"[..]; - /// assert_eq!(Err(TryGetError{requested: 8, available: 7}), buf.try_get_f64_ne()); - /// assert_eq!(7, buf.remaining()); - /// ``` - fn try_get_f64_ne(&mut self) -> Result<f64, TryGetError> { - Ok(f64::from_bits(self.try_get_u64_ne()?)) - } - - /// Consumes `len` bytes inside self and returns new instance of `Bytes` - /// with this data. - /// - /// This function may be optimized by the underlying type to avoid actual - /// copies. For example, `Bytes` implementation will do a shallow copy - /// (ref-count increment). - /// - /// # Examples - /// - /// ``` - /// use bytes::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(&TryGetError { - requested: len, - available: self.remaining(), - }); - } - - let mut ret = crate::BytesMut::with_capacity(len); - ret.put(self.take(len)); - ret.freeze() - } - - /// Creates an adaptor which will read at most `limit` bytes from `self`. - /// - /// This function returns a new instance of `Buf` which will read at most - /// `limit` bytes. - /// - /// # Examples - /// - /// ``` - /// use bytes::{Buf, BufMut}; - /// - /// let mut buf = b"hello world"[..].take(5); - /// let mut dst = vec![]; - /// - /// dst.put(&mut buf); - /// assert_eq!(dst, b"hello"); - /// - /// let mut buf = buf.into_inner(); - /// dst.clear(); - /// dst.put(&mut buf); - /// assert_eq!(dst, b" world"); - /// ``` - fn take(self, limit: usize) -> Take<Self> - where - Self: Sized, - { - take::new(self, limit) - } - - /// Creates an adaptor which will chain this buffer with another. - /// - /// The returned `Buf` instance will first consume all bytes from `self`. - /// Afterwards the output is equivalent to the output of next. - /// - /// # Examples - /// - /// ``` - /// use bytes::Buf; - /// - /// let mut chain = b"hello "[..].chain(&b"world"[..]); - /// - /// let full = chain.copy_to_bytes(11); - /// assert_eq!(full.chunk(), b"hello world"); - /// ``` - fn chain<U: Buf>(self, next: U) -> Chain<Self, U> - where - Self: Sized, - { - Chain::new(self, next) - } - - /// Creates an adaptor which implements the `Read` trait for `self`. - /// - /// This function returns a new value which implements `Read` by adapting - /// the `Read` trait functions to the `Buf` trait functions. Given that - /// `Buf` operations are infallible, none of the `Read` functions will - /// return with `Err`. - /// - /// # Examples - /// - /// ``` - /// use bytes::{Bytes, Buf}; - /// use std::io::Read; - /// - /// let buf = Bytes::from("hello world"); - /// - /// let mut reader = buf.reader(); - /// let mut dst = [0; 1024]; - /// - /// let num = reader.read(&mut dst).unwrap(); - /// - /// assert_eq!(11, num); - /// assert_eq!(&dst[..11], &b"hello world"[..]); - /// ``` - #[cfg(feature = "std")] - #[cfg_attr(docsrs, doc(cfg(feature = "std")))] - fn reader(self) -> Reader<Self> - where - Self: Sized, - { - reader::new(self) - } -} - -macro_rules! deref_forward_buf { - () => { - #[inline] - fn remaining(&self) -> usize { - (**self).remaining() - } - - #[inline] - fn chunk(&self) -> &[u8] { - (**self).chunk() - } - - #[cfg(feature = "std")] - #[inline] - fn chunks_vectored<'b>(&'b self, dst: &mut [IoSlice<'b>]) -> usize { - (**self).chunks_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_u128(&mut self) -> u128 { - (**self).get_u128() - } - - #[inline] - fn get_u128_le(&mut self) -> u128 { - (**self).get_u128_le() - } - - #[inline] - fn get_u128_ne(&mut self) -> u128 { - (**self).get_u128_ne() - } - - #[inline] - fn get_i128(&mut self) -> i128 { - (**self).get_i128() - } - - #[inline] - fn get_i128_le(&mut self) -> i128 { - (**self).get_i128_le() - } - - #[inline] - fn get_i128_ne(&mut self) -> i128 { - (**self).get_i128_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 get_f32(&mut self) -> f32 { - (**self).get_f32() - } - - #[inline] - fn get_f32_le(&mut self) -> f32 { - (**self).get_f32_le() - } - - #[inline] - fn get_f32_ne(&mut self) -> f32 { - (**self).get_f32_ne() - } - - #[inline] - fn get_f64(&mut self) -> f64 { - (**self).get_f64() - } - - #[inline] - fn get_f64_le(&mut self) -> f64 { - (**self).get_f64_le() - } - - #[inline] - fn get_f64_ne(&mut self) -> f64 { - (**self).get_f64_ne() - } - - #[inline] - fn try_copy_to_slice(&mut self, dst: &mut [u8]) -> Result<(), TryGetError> { - (**self).try_copy_to_slice(dst) - } - - #[inline] - fn try_get_u8(&mut self) -> Result<u8, TryGetError> { - (**self).try_get_u8() - } - - #[inline] - fn try_get_i8(&mut self) -> Result<i8, TryGetError> { - (**self).try_get_i8() - } - - #[inline] - fn try_get_u16(&mut self) -> Result<u16, TryGetError> { - (**self).try_get_u16() - } - - #[inline] - fn try_get_u16_le(&mut self) -> Result<u16, TryGetError> { - (**self).try_get_u16_le() - } - - #[inline] - fn try_get_u16_ne(&mut self) -> Result<u16, TryGetError> { - (**self).try_get_u16_ne() - } - - #[inline] - fn try_get_i16(&mut self) -> Result<i16, TryGetError> { - (**self).try_get_i16() - } - - #[inline] - fn try_get_i16_le(&mut self) -> Result<i16, TryGetError> { - (**self).try_get_i16_le() - } - - #[inline] - fn try_get_i16_ne(&mut self) -> Result<i16, TryGetError> { - (**self).try_get_i16_ne() - } - - #[inline] - fn try_get_u32(&mut self) -> Result<u32, TryGetError> { - (**self).try_get_u32() - } - - #[inline] - fn try_get_u32_le(&mut self) -> Result<u32, TryGetError> { - (**self).try_get_u32_le() - } - - #[inline] - fn try_get_u32_ne(&mut self) -> Result<u32, TryGetError> { - (**self).try_get_u32_ne() - } - - #[inline] - fn try_get_i32(&mut self) -> Result<i32, TryGetError> { - (**self).try_get_i32() - } - - #[inline] - fn try_get_i32_le(&mut self) -> Result<i32, TryGetError> { - (**self).try_get_i32_le() - } - - #[inline] - fn try_get_i32_ne(&mut self) -> Result<i32, TryGetError> { - (**self).try_get_i32_ne() - } - - #[inline] - fn try_get_u64(&mut self) -> Result<u64, TryGetError> { - (**self).try_get_u64() - } - - #[inline] - fn try_get_u64_le(&mut self) -> Result<u64, TryGetError> { - (**self).try_get_u64_le() - } - - #[inline] - fn try_get_u64_ne(&mut self) -> Result<u64, TryGetError> { - (**self).try_get_u64_ne() - } - - #[inline] - fn try_get_i64(&mut self) -> Result<i64, TryGetError> { - (**self).try_get_i64() - } - - #[inline] - fn try_get_i64_le(&mut self) -> Result<i64, TryGetError> { - (**self).try_get_i64_le() - } - - #[inline] - fn try_get_i64_ne(&mut self) -> Result<i64, TryGetError> { - (**self).try_get_i64_ne() - } - - #[inline] - fn try_get_u128(&mut self) -> Result<u128, TryGetError> { - (**self).try_get_u128() - } - - #[inline] - fn try_get_u128_le(&mut self) -> Result<u128, TryGetError> { - (**self).try_get_u128_le() - } - - #[inline] - fn try_get_u128_ne(&mut self) -> Result<u128, TryGetError> { - (**self).try_get_u128_ne() - } - - #[inline] - fn try_get_i128(&mut self) -> Result<i128, TryGetError> { - (**self).try_get_i128() - } - - #[inline] - fn try_get_i128_le(&mut self) -> Result<i128, TryGetError> { - (**self).try_get_i128_le() - } - - #[inline] - fn try_get_i128_ne(&mut self) -> Result<i128, TryGetError> { - (**self).try_get_i128_ne() - } - - #[inline] - fn try_get_uint(&mut self, nbytes: usize) -> Result<u64, TryGetError> { - (**self).try_get_uint(nbytes) - } - - #[inline] - fn try_get_uint_le(&mut self, nbytes: usize) -> Result<u64, TryGetError> { - (**self).try_get_uint_le(nbytes) - } - - #[inline] - fn try_get_uint_ne(&mut self, nbytes: usize) -> Result<u64, TryGetError> { - (**self).try_get_uint_ne(nbytes) - } - - #[inline] - fn try_get_int(&mut self, nbytes: usize) -> Result<i64, TryGetError> { - (**self).try_get_int(nbytes) - } - - #[inline] - fn try_get_int_le(&mut self, nbytes: usize) -> Result<i64, TryGetError> { - (**self).try_get_int_le(nbytes) - } - - #[inline] - fn try_get_int_ne(&mut self, nbytes: usize) -> Result<i64, TryGetError> { - (**self).try_get_int_ne(nbytes) - } - - #[inline] - fn try_get_f32(&mut self) -> Result<f32, TryGetError> { - (**self).try_get_f32() - } - - #[inline] - fn try_get_f32_le(&mut self) -> Result<f32, TryGetError> { - (**self).try_get_f32_le() - } - - #[inline] - fn try_get_f32_ne(&mut self) -> Result<f32, TryGetError> { - (**self).try_get_f32_ne() - } - - #[inline] - fn try_get_f64(&mut self) -> Result<f64, TryGetError> { - (**self).try_get_f64() - } - - #[inline] - fn try_get_f64_le(&mut self) -> Result<f64, TryGetError> { - (**self).try_get_f64_le() - } - - #[inline] - fn try_get_f64_ne(&mut self) -> Result<f64, TryGetError> { - (**self).try_get_f64_ne() - } - - #[inline] - fn copy_to_bytes(&mut self, len: usize) -> crate::Bytes { - (**self).copy_to_bytes(len) - } - }; -} - -impl<T: Buf + ?Sized> Buf for &mut T { - deref_forward_buf!(); -} - -impl<T: Buf + ?Sized> Buf for Box<T> { - deref_forward_buf!(); -} - -impl Buf for &[u8] { - #[inline] - fn remaining(&self) -> usize { - self.len() - } - - #[inline] - fn chunk(&self) -> &[u8] { - self - } - - #[inline] - fn advance(&mut self, cnt: usize) { - if self.len() < cnt { - panic_advance(&TryGetError { - requested: cnt, - available: self.len(), - }); - } - - *self = &self[cnt..]; - } - - #[inline] - fn copy_to_slice(&mut self, dst: &mut [u8]) { - if self.len() < dst.len() { - panic_advance(&TryGetError { - requested: dst.len(), - available: self.len(), - }); - } - - dst.copy_from_slice(&self[..dst.len()]); - self.advance(dst.len()); - } -} - -#[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(&TryGetError { - requested: cnt, - available: max_cnt, - }); - } - - // This will not overflow because either `cnt == 0` or the sum is not - // greater than `len`. - self.set_position(pos + cnt as u64); - } -} - -// The existence of this function makes the compiler catch if the Buf -// trait is "object-safe" or not. -fn _assert_trait_object(_b: &dyn Buf) {} diff --git a/vendor/bytes/src/buf/buf_mut.rs b/vendor/bytes/src/buf/buf_mut.rs deleted file mode 100644 index 26645c6a..00000000 --- a/vendor/bytes/src/buf/buf_mut.rs +++ /dev/null @@ -1,1671 +0,0 @@ -use crate::buf::{limit, Chain, Limit, UninitSlice}; -#[cfg(feature = "std")] -use crate::buf::{writer, Writer}; -use crate::{panic_advance, panic_does_not_fit, TryGetError}; - -use core::{mem, ptr, usize}; - -use alloc::{boxed::Box, vec::Vec}; - -/// A trait for values that provide sequential write access to bytes. -/// -/// Write bytes to a buffer -/// -/// A buffer stores bytes in memory such that write operations are infallible. -/// The underlying storage may or may not be in contiguous memory. A `BufMut` -/// value is a cursor into the buffer. Writing to `BufMut` advances the cursor -/// position. -/// -/// The simplest `BufMut` is a `Vec<u8>`. -/// -/// ``` -/// use bytes::BufMut; -/// -/// let mut buf = vec![]; -/// -/// buf.put(&b"hello world"[..]); -/// -/// assert_eq!(buf, b"hello world"); -/// ``` -pub unsafe trait BufMut { - /// Returns the number of bytes that can be written from the current - /// position until the end of the buffer is reached. - /// - /// This value is greater than or equal to the length of the slice returned - /// by `chunk_mut()`. - /// - /// Writing to a `BufMut` may involve allocating more memory on the fly. - /// Implementations may fail before reaching the number of bytes indicated - /// by this method if they encounter an allocation failure. - /// - /// # Examples - /// - /// ``` - /// use bytes::BufMut; - /// - /// let mut dst = [0; 10]; - /// let mut buf = &mut dst[..]; - /// - /// let original_remaining = buf.remaining_mut(); - /// buf.put(&b"hello"[..]); - /// - /// assert_eq!(original_remaining - 5, buf.remaining_mut()); - /// ``` - /// - /// # Implementer notes - /// - /// Implementations of `remaining_mut` should ensure that the return value - /// does not change unless a call is made to `advance_mut` or any other - /// function that is documented to change the `BufMut`'s current position. - /// - /// # Note - /// - /// `remaining_mut` may return value smaller than actual available space. - fn remaining_mut(&self) -> usize; - - /// Advance the internal cursor of the BufMut - /// - /// The next call to `chunk_mut` will return a slice starting `cnt` bytes - /// further into the underlying buffer. - /// - /// # Safety - /// - /// The caller must ensure that the next `cnt` bytes of `chunk` are - /// initialized. - /// - /// # Examples - /// - /// ``` - /// use bytes::BufMut; - /// - /// let mut buf = Vec::with_capacity(16); - /// - /// // Write some data - /// buf.chunk_mut()[0..2].copy_from_slice(b"he"); - /// unsafe { buf.advance_mut(2) }; - /// - /// // write more bytes - /// buf.chunk_mut()[0..3].copy_from_slice(b"llo"); - /// - /// unsafe { buf.advance_mut(3); } - /// - /// assert_eq!(5, buf.len()); - /// assert_eq!(buf, b"hello"); - /// ``` - /// - /// # Panics - /// - /// This function **may** panic if `cnt > self.remaining_mut()`. - /// - /// # Implementer notes - /// - /// It is recommended for implementations of `advance_mut` to panic if - /// `cnt > self.remaining_mut()`. If the implementation does not panic, - /// the call must behave as if `cnt == self.remaining_mut()`. - /// - /// A call with `cnt == 0` should never panic and be a no-op. - unsafe fn advance_mut(&mut self, cnt: usize); - - /// Returns true if there is space in `self` for more bytes. - /// - /// This is equivalent to `self.remaining_mut() != 0`. - /// - /// # Examples - /// - /// ``` - /// use bytes::BufMut; - /// - /// let mut dst = [0; 5]; - /// let mut buf = &mut dst[..]; - /// - /// assert!(buf.has_remaining_mut()); - /// - /// buf.put(&b"hello"[..]); - /// - /// assert!(!buf.has_remaining_mut()); - /// ``` - #[inline] - fn has_remaining_mut(&self) -> bool { - self.remaining_mut() > 0 - } - - /// Returns a mutable slice starting at the current BufMut position and of - /// length between 0 and `BufMut::remaining_mut()`. Note that this *can* be shorter than the - /// whole remainder of the buffer (this allows non-continuous implementation). - /// - /// This is a lower level function. Most operations are done with other - /// functions. - /// - /// The returned byte slice may represent uninitialized memory. - /// - /// # Examples - /// - /// ``` - /// use bytes::BufMut; - /// - /// let mut buf = Vec::with_capacity(16); - /// - /// unsafe { - /// // MaybeUninit::as_mut_ptr - /// buf.chunk_mut()[0..].as_mut_ptr().write(b'h'); - /// buf.chunk_mut()[1..].as_mut_ptr().write(b'e'); - /// - /// buf.advance_mut(2); - /// - /// buf.chunk_mut()[0..].as_mut_ptr().write(b'l'); - /// buf.chunk_mut()[1..].as_mut_ptr().write(b'l'); - /// buf.chunk_mut()[2..].as_mut_ptr().write(b'o'); - /// - /// buf.advance_mut(3); - /// } - /// - /// assert_eq!(5, buf.len()); - /// assert_eq!(buf, b"hello"); - /// ``` - /// - /// # Implementer notes - /// - /// This function should never panic. `chunk_mut()` should return an empty - /// slice **if and only if** `remaining_mut()` returns 0. In other words, - /// `chunk_mut()` returning an empty slice implies that `remaining_mut()` will - /// return 0 and `remaining_mut()` returning 0 implies that `chunk_mut()` will - /// return an empty slice. - /// - /// This function may trigger an out-of-memory abort if it tries to allocate - /// memory and fails to do so. - // The `chunk_mut` method was previously called `bytes_mut`. This alias makes the - // rename more easily discoverable. - #[cfg_attr(docsrs, doc(alias = "bytes_mut"))] - fn chunk_mut(&mut self) -> &mut UninitSlice; - - /// Transfer bytes into `self` from `src` and advance the cursor by the - /// number of bytes written. - /// - /// # Examples - /// - /// ``` - /// use bytes::BufMut; - /// - /// let mut buf = vec![]; - /// - /// buf.put_u8(b'h'); - /// buf.put(&b"ello"[..]); - /// buf.put(&b" world"[..]); - /// - /// assert_eq!(buf, b"hello world"); - /// ``` - /// - /// # Panics - /// - /// Panics if `self` does not have enough capacity to contain `src`. - #[inline] - fn put<T: super::Buf>(&mut self, mut src: T) - where - Self: Sized, - { - if self.remaining_mut() < src.remaining() { - panic_advance(&TryGetError { - requested: src.remaining(), - available: self.remaining_mut(), - }); - } - - while src.has_remaining() { - let s = src.chunk(); - let d = self.chunk_mut(); - let cnt = usize::min(s.len(), d.len()); - - d[..cnt].copy_from_slice(&s[..cnt]); - - // SAFETY: We just initialized `cnt` bytes in `self`. - unsafe { self.advance_mut(cnt) }; - src.advance(cnt); - } - } - - /// Transfer bytes into `self` from `src` and advance the cursor by the - /// number of bytes written. - /// - /// `self` must have enough remaining capacity to contain all of `src`. - /// - /// ``` - /// use bytes::BufMut; - /// - /// let mut dst = [0; 6]; - /// - /// { - /// let mut buf = &mut dst[..]; - /// buf.put_slice(b"hello"); - /// - /// assert_eq!(1, buf.remaining_mut()); - /// } - /// - /// assert_eq!(b"hello\0", &dst); - /// ``` - #[inline] - fn put_slice(&mut self, mut src: &[u8]) { - if self.remaining_mut() < src.len() { - panic_advance(&TryGetError { - requested: src.len(), - available: self.remaining_mut(), - }); - } - - while !src.is_empty() { - let dst = self.chunk_mut(); - let cnt = usize::min(src.len(), dst.len()); - - dst[..cnt].copy_from_slice(&src[..cnt]); - src = &src[cnt..]; - - // SAFETY: We just initialized `cnt` bytes in `self`. - unsafe { self.advance_mut(cnt) }; - } - } - - /// Put `cnt` bytes `val` into `self`. - /// - /// Logically equivalent to calling `self.put_u8(val)` `cnt` times, but may work faster. - /// - /// `self` must have at least `cnt` remaining capacity. - /// - /// ``` - /// use bytes::BufMut; - /// - /// let mut dst = [0; 6]; - /// - /// { - /// let mut buf = &mut dst[..]; - /// buf.put_bytes(b'a', 4); - /// - /// assert_eq!(2, buf.remaining_mut()); - /// } - /// - /// assert_eq!(b"aaaa\0\0", &dst); - /// ``` - /// - /// # Panics - /// - /// This function panics if there is not enough remaining capacity in - /// `self`. - #[inline] - fn put_bytes(&mut self, val: u8, mut cnt: usize) { - if self.remaining_mut() < cnt { - panic_advance(&TryGetError { - requested: cnt, - available: self.remaining_mut(), - }) - } - - while cnt > 0 { - let dst = self.chunk_mut(); - let dst_len = usize::min(dst.len(), cnt); - // SAFETY: The pointer is valid for `dst_len <= dst.len()` bytes. - unsafe { core::ptr::write_bytes(dst.as_mut_ptr(), val, dst_len) }; - // SAFETY: We just initialized `dst_len` bytes in `self`. - unsafe { self.advance_mut(dst_len) }; - cnt -= dst_len; - } - } - - /// Writes an unsigned 8 bit integer to `self`. - /// - /// The current position is advanced by 1. - /// - /// # Examples - /// - /// ``` - /// use bytes::BufMut; - /// - /// let mut buf = vec![]; - /// buf.put_u8(0x01); - /// assert_eq!(buf, b"\x01"); - /// ``` - /// - /// # Panics - /// - /// This function panics if there is not enough remaining capacity in - /// `self`. - #[inline] - fn put_u8(&mut self, n: u8) { - let src = [n]; - self.put_slice(&src); - } - - /// Writes a signed 8 bit integer to `self`. - /// - /// The current position is advanced by 1. - /// - /// # Examples - /// - /// ``` - /// use bytes::BufMut; - /// - /// let mut buf = vec![]; - /// buf.put_i8(0x01); - /// assert_eq!(buf, b"\x01"); - /// ``` - /// - /// # Panics - /// - /// This function panics if there is not enough remaining capacity in - /// `self`. - #[inline] - fn put_i8(&mut self, n: i8) { - let src = [n as u8]; - self.put_slice(&src) - } - - /// Writes an unsigned 16 bit integer to `self` in big-endian byte order. - /// - /// The current position is advanced by 2. - /// - /// # Examples - /// - /// ``` - /// use bytes::BufMut; - /// - /// let mut buf = vec![]; - /// buf.put_u16(0x0809); - /// assert_eq!(buf, b"\x08\x09"); - /// ``` - /// - /// # Panics - /// - /// This function panics if there is not enough remaining capacity in - /// `self`. - #[inline] - fn put_u16(&mut self, n: u16) { - self.put_slice(&n.to_be_bytes()) - } - - /// Writes an unsigned 16 bit integer to `self` in little-endian byte order. - /// - /// The current position is advanced by 2. - /// - /// # Examples - /// - /// ``` - /// use bytes::BufMut; - /// - /// let mut buf = vec![]; - /// buf.put_u16_le(0x0809); - /// assert_eq!(buf, b"\x09\x08"); - /// ``` - /// - /// # Panics - /// - /// This function panics if there is not enough remaining capacity in - /// `self`. - #[inline] - fn put_u16_le(&mut self, n: u16) { - self.put_slice(&n.to_le_bytes()) - } - - /// Writes an unsigned 16 bit integer to `self` in native-endian byte order. - /// - /// The current position is advanced by 2. - /// - /// # Examples - /// - /// ``` - /// use bytes::BufMut; - /// - /// let mut buf = vec![]; - /// buf.put_u16_ne(0x0809); - /// if cfg!(target_endian = "big") { - /// assert_eq!(buf, b"\x08\x09"); - /// } else { - /// assert_eq!(buf, b"\x09\x08"); - /// } - /// ``` - /// - /// # Panics - /// - /// This function panics if there is not enough remaining capacity in - /// `self`. - #[inline] - fn put_u16_ne(&mut self, n: u16) { - self.put_slice(&n.to_ne_bytes()) - } - - /// Writes a signed 16 bit integer to `self` in big-endian byte order. - /// - /// The current position is advanced by 2. - /// - /// # Examples - /// - /// ``` - /// use bytes::BufMut; - /// - /// let mut buf = vec![]; - /// buf.put_i16(0x0809); - /// assert_eq!(buf, b"\x08\x09"); - /// ``` - /// - /// # Panics - /// - /// This function panics if there is not enough remaining capacity in - /// `self`. - #[inline] - fn put_i16(&mut self, n: i16) { - self.put_slice(&n.to_be_bytes()) - } - - /// Writes a signed 16 bit integer to `self` in little-endian byte order. - /// - /// The current position is advanced by 2. - /// - /// # Examples - /// - /// ``` - /// use bytes::BufMut; - /// - /// let mut buf = vec![]; - /// buf.put_i16_le(0x0809); - /// assert_eq!(buf, b"\x09\x08"); - /// ``` - /// - /// # Panics - /// - /// This function panics if there is not enough remaining capacity in - /// `self`. - #[inline] - fn put_i16_le(&mut self, n: i16) { - self.put_slice(&n.to_le_bytes()) - } - - /// Writes a signed 16 bit integer to `self` in native-endian byte order. - /// - /// The current position is advanced by 2. - /// - /// # Examples - /// - /// ``` - /// use bytes::BufMut; - /// - /// let mut buf = vec![]; - /// buf.put_i16_ne(0x0809); - /// if cfg!(target_endian = "big") { - /// assert_eq!(buf, b"\x08\x09"); - /// } else { - /// assert_eq!(buf, b"\x09\x08"); - /// } - /// ``` - /// - /// # Panics - /// - /// This function panics if there is not enough remaining capacity in - /// `self`. - #[inline] - fn put_i16_ne(&mut self, n: i16) { - self.put_slice(&n.to_ne_bytes()) - } - - /// Writes an unsigned 32 bit integer to `self` in big-endian byte order. - /// - /// The current position is advanced by 4. - /// - /// # Examples - /// - /// ``` - /// use bytes::BufMut; - /// - /// let mut buf = vec![]; - /// buf.put_u32(0x0809A0A1); - /// assert_eq!(buf, b"\x08\x09\xA0\xA1"); - /// ``` - /// - /// # Panics - /// - /// This function panics if there is not enough remaining capacity in - /// `self`. - #[inline] - fn put_u32(&mut self, n: u32) { - self.put_slice(&n.to_be_bytes()) - } - - /// Writes an unsigned 32 bit integer to `self` in little-endian byte order. - /// - /// The current position is advanced by 4. - /// - /// # Examples - /// - /// ``` - /// use bytes::BufMut; - /// - /// let mut buf = vec![]; - /// buf.put_u32_le(0x0809A0A1); - /// assert_eq!(buf, b"\xA1\xA0\x09\x08"); - /// ``` - /// - /// # Panics - /// - /// This function panics if there is not enough remaining capacity in - /// `self`. - #[inline] - fn put_u32_le(&mut self, n: u32) { - self.put_slice(&n.to_le_bytes()) - } - - /// Writes an unsigned 32 bit integer to `self` in native-endian byte order. - /// - /// The current position is advanced by 4. - /// - /// # Examples - /// - /// ``` - /// use bytes::BufMut; - /// - /// let mut buf = vec![]; - /// buf.put_u32_ne(0x0809A0A1); - /// if cfg!(target_endian = "big") { - /// assert_eq!(buf, b"\x08\x09\xA0\xA1"); - /// } else { - /// assert_eq!(buf, b"\xA1\xA0\x09\x08"); - /// } - /// ``` - /// - /// # Panics - /// - /// This function panics if there is not enough remaining capacity in - /// `self`. - #[inline] - fn put_u32_ne(&mut self, n: u32) { - self.put_slice(&n.to_ne_bytes()) - } - - /// Writes a signed 32 bit integer to `self` in big-endian byte order. - /// - /// The current position is advanced by 4. - /// - /// # Examples - /// - /// ``` - /// use bytes::BufMut; - /// - /// let mut buf = vec![]; - /// buf.put_i32(0x0809A0A1); - /// assert_eq!(buf, b"\x08\x09\xA0\xA1"); - /// ``` - /// - /// # Panics - /// - /// This function panics if there is not enough remaining capacity in - /// `self`. - #[inline] - fn put_i32(&mut self, n: i32) { - self.put_slice(&n.to_be_bytes()) - } - - /// Writes a signed 32 bit integer to `self` in little-endian byte order. - /// - /// The current position is advanced by 4. - /// - /// # Examples - /// - /// ``` - /// use bytes::BufMut; - /// - /// let mut buf = vec![]; - /// buf.put_i32_le(0x0809A0A1); - /// assert_eq!(buf, b"\xA1\xA0\x09\x08"); - /// ``` - /// - /// # Panics - /// - /// This function panics if there is not enough remaining capacity in - /// `self`. - #[inline] - fn put_i32_le(&mut self, n: i32) { - self.put_slice(&n.to_le_bytes()) - } - - /// Writes a signed 32 bit integer to `self` in native-endian byte order. - /// - /// The current position is advanced by 4. - /// - /// # Examples - /// - /// ``` - /// use bytes::BufMut; - /// - /// let mut buf = vec![]; - /// buf.put_i32_ne(0x0809A0A1); - /// if cfg!(target_endian = "big") { - /// assert_eq!(buf, b"\x08\x09\xA0\xA1"); - /// } else { - /// assert_eq!(buf, b"\xA1\xA0\x09\x08"); - /// } - /// ``` - /// - /// # Panics - /// - /// This function panics if there is not enough remaining capacity in - /// `self`. - #[inline] - fn put_i32_ne(&mut self, n: i32) { - self.put_slice(&n.to_ne_bytes()) - } - - /// Writes an unsigned 64 bit integer to `self` in the big-endian byte order. - /// - /// The current position is advanced by 8. - /// - /// # Examples - /// - /// ``` - /// use bytes::BufMut; - /// - /// let mut buf = vec![]; - /// buf.put_u64(0x0102030405060708); - /// assert_eq!(buf, b"\x01\x02\x03\x04\x05\x06\x07\x08"); - /// ``` - /// - /// # Panics - /// - /// This function panics if there is not enough remaining capacity in - /// `self`. - #[inline] - fn put_u64(&mut self, n: u64) { - self.put_slice(&n.to_be_bytes()) - } - - /// Writes an unsigned 64 bit integer to `self` in little-endian byte order. - /// - /// The current position is advanced by 8. - /// - /// # Examples - /// - /// ``` - /// use bytes::BufMut; - /// - /// let mut buf = vec![]; - /// buf.put_u64_le(0x0102030405060708); - /// assert_eq!(buf, b"\x08\x07\x06\x05\x04\x03\x02\x01"); - /// ``` - /// - /// # Panics - /// - /// This function panics if there is not enough remaining capacity in - /// `self`. - #[inline] - fn put_u64_le(&mut self, n: u64) { - self.put_slice(&n.to_le_bytes()) - } - - /// Writes an unsigned 64 bit integer to `self` in native-endian byte order. - /// - /// The current position is advanced by 8. - /// - /// # Examples - /// - /// ``` - /// use bytes::BufMut; - /// - /// let mut buf = vec![]; - /// buf.put_u64_ne(0x0102030405060708); - /// if cfg!(target_endian = "big") { - /// assert_eq!(buf, b"\x01\x02\x03\x04\x05\x06\x07\x08"); - /// } else { - /// assert_eq!(buf, b"\x08\x07\x06\x05\x04\x03\x02\x01"); - /// } - /// ``` - /// - /// # Panics - /// - /// This function panics if there is not enough remaining capacity in - /// `self`. - #[inline] - fn put_u64_ne(&mut self, n: u64) { - self.put_slice(&n.to_ne_bytes()) - } - - /// Writes a signed 64 bit integer to `self` in the big-endian byte order. - /// - /// The current position is advanced by 8. - /// - /// # Examples - /// - /// ``` - /// use bytes::BufMut; - /// - /// let mut buf = vec![]; - /// buf.put_i64(0x0102030405060708); - /// assert_eq!(buf, b"\x01\x02\x03\x04\x05\x06\x07\x08"); - /// ``` - /// - /// # Panics - /// - /// This function panics if there is not enough remaining capacity in - /// `self`. - #[inline] - fn put_i64(&mut self, n: i64) { - self.put_slice(&n.to_be_bytes()) - } - - /// Writes a signed 64 bit integer to `self` in little-endian byte order. - /// - /// The current position is advanced by 8. - /// - /// # Examples - /// - /// ``` - /// use bytes::BufMut; - /// - /// let mut buf = vec![]; - /// buf.put_i64_le(0x0102030405060708); - /// assert_eq!(buf, b"\x08\x07\x06\x05\x04\x03\x02\x01"); - /// ``` - /// - /// # Panics - /// - /// This function panics if there is not enough remaining capacity in - /// `self`. - #[inline] - fn put_i64_le(&mut self, n: i64) { - self.put_slice(&n.to_le_bytes()) - } - - /// Writes a signed 64 bit integer to `self` in native-endian byte order. - /// - /// The current position is advanced by 8. - /// - /// # Examples - /// - /// ``` - /// use bytes::BufMut; - /// - /// let mut buf = vec![]; - /// buf.put_i64_ne(0x0102030405060708); - /// if cfg!(target_endian = "big") { - /// assert_eq!(buf, b"\x01\x02\x03\x04\x05\x06\x07\x08"); - /// } else { - /// assert_eq!(buf, b"\x08\x07\x06\x05\x04\x03\x02\x01"); - /// } - /// ``` - /// - /// # Panics - /// - /// This function panics if there is not enough remaining capacity in - /// `self`. - #[inline] - fn put_i64_ne(&mut self, n: i64) { - self.put_slice(&n.to_ne_bytes()) - } - - /// Writes an unsigned 128 bit integer to `self` in the big-endian byte order. - /// - /// The current position is advanced by 16. - /// - /// # Examples - /// - /// ``` - /// use bytes::BufMut; - /// - /// let mut buf = vec![]; - /// buf.put_u128(0x01020304050607080910111213141516); - /// assert_eq!(buf, b"\x01\x02\x03\x04\x05\x06\x07\x08\x09\x10\x11\x12\x13\x14\x15\x16"); - /// ``` - /// - /// # Panics - /// - /// This function panics if there is not enough remaining capacity in - /// `self`. - #[inline] - fn put_u128(&mut self, n: u128) { - self.put_slice(&n.to_be_bytes()) - } - - /// Writes an unsigned 128 bit integer to `self` in little-endian byte order. - /// - /// The current position is advanced by 16. - /// - /// # Examples - /// - /// ``` - /// use bytes::BufMut; - /// - /// let mut buf = vec![]; - /// buf.put_u128_le(0x01020304050607080910111213141516); - /// assert_eq!(buf, b"\x16\x15\x14\x13\x12\x11\x10\x09\x08\x07\x06\x05\x04\x03\x02\x01"); - /// ``` - /// - /// # Panics - /// - /// This function panics if there is not enough remaining capacity in - /// `self`. - #[inline] - fn put_u128_le(&mut self, n: u128) { - self.put_slice(&n.to_le_bytes()) - } - - /// Writes an unsigned 128 bit integer to `self` in native-endian byte order. - /// - /// The current position is advanced by 16. - /// - /// # Examples - /// - /// ``` - /// use bytes::BufMut; - /// - /// let mut buf = vec![]; - /// buf.put_u128_ne(0x01020304050607080910111213141516); - /// if cfg!(target_endian = "big") { - /// assert_eq!(buf, b"\x01\x02\x03\x04\x05\x06\x07\x08\x09\x10\x11\x12\x13\x14\x15\x16"); - /// } else { - /// assert_eq!(buf, b"\x16\x15\x14\x13\x12\x11\x10\x09\x08\x07\x06\x05\x04\x03\x02\x01"); - /// } - /// ``` - /// - /// # Panics - /// - /// This function panics if there is not enough remaining capacity in - /// `self`. - #[inline] - fn put_u128_ne(&mut self, n: u128) { - self.put_slice(&n.to_ne_bytes()) - } - - /// Writes a signed 128 bit integer to `self` in the big-endian byte order. - /// - /// The current position is advanced by 16. - /// - /// # Examples - /// - /// ``` - /// use bytes::BufMut; - /// - /// let mut buf = vec![]; - /// buf.put_i128(0x01020304050607080910111213141516); - /// assert_eq!(buf, b"\x01\x02\x03\x04\x05\x06\x07\x08\x09\x10\x11\x12\x13\x14\x15\x16"); - /// ``` - /// - /// # Panics - /// - /// This function panics if there is not enough remaining capacity in - /// `self`. - #[inline] - fn put_i128(&mut self, n: i128) { - self.put_slice(&n.to_be_bytes()) - } - - /// Writes a signed 128 bit integer to `self` in little-endian byte order. - /// - /// The current position is advanced by 16. - /// - /// # Examples - /// - /// ``` - /// use bytes::BufMut; - /// - /// let mut buf = vec![]; - /// buf.put_i128_le(0x01020304050607080910111213141516); - /// assert_eq!(buf, b"\x16\x15\x14\x13\x12\x11\x10\x09\x08\x07\x06\x05\x04\x03\x02\x01"); - /// ``` - /// - /// # Panics - /// - /// This function panics if there is not enough remaining capacity in - /// `self`. - #[inline] - fn put_i128_le(&mut self, n: i128) { - self.put_slice(&n.to_le_bytes()) - } - - /// Writes a signed 128 bit integer to `self` in native-endian byte order. - /// - /// The current position is advanced by 16. - /// - /// # Examples - /// - /// ``` - /// use bytes::BufMut; - /// - /// let mut buf = vec![]; - /// buf.put_i128_ne(0x01020304050607080910111213141516); - /// if cfg!(target_endian = "big") { - /// assert_eq!(buf, b"\x01\x02\x03\x04\x05\x06\x07\x08\x09\x10\x11\x12\x13\x14\x15\x16"); - /// } else { - /// assert_eq!(buf, b"\x16\x15\x14\x13\x12\x11\x10\x09\x08\x07\x06\x05\x04\x03\x02\x01"); - /// } - /// ``` - /// - /// # Panics - /// - /// This function panics if there is not enough remaining capacity in - /// `self`. - #[inline] - fn put_i128_ne(&mut self, n: i128) { - self.put_slice(&n.to_ne_bytes()) - } - - /// Writes an unsigned n-byte integer to `self` in big-endian byte order. - /// - /// The current position is advanced by `nbytes`. - /// - /// # Examples - /// - /// ``` - /// use bytes::BufMut; - /// - /// let mut buf = vec![]; - /// buf.put_uint(0x010203, 3); - /// assert_eq!(buf, b"\x01\x02\x03"); - /// ``` - /// - /// # Panics - /// - /// This function panics if there is not enough remaining capacity in - /// `self` or if `nbytes` is greater than 8. - #[inline] - fn put_uint(&mut self, n: u64, nbytes: usize) { - let start = match mem::size_of_val(&n).checked_sub(nbytes) { - Some(start) => start, - None => panic_does_not_fit(nbytes, mem::size_of_val(&n)), - }; - - self.put_slice(&n.to_be_bytes()[start..]); - } - - /// Writes an unsigned n-byte integer to `self` in the little-endian byte order. - /// - /// The current position is advanced by `nbytes`. - /// - /// # Examples - /// - /// ``` - /// use bytes::BufMut; - /// - /// let mut buf = vec![]; - /// buf.put_uint_le(0x010203, 3); - /// assert_eq!(buf, b"\x03\x02\x01"); - /// ``` - /// - /// # Panics - /// - /// This function panics if there is not enough remaining capacity in - /// `self` or if `nbytes` is greater than 8. - #[inline] - fn put_uint_le(&mut self, n: u64, nbytes: usize) { - let slice = n.to_le_bytes(); - let slice = match slice.get(..nbytes) { - Some(slice) => slice, - None => panic_does_not_fit(nbytes, slice.len()), - }; - - self.put_slice(slice); - } - - /// Writes an unsigned n-byte integer to `self` in the native-endian byte order. - /// - /// The current position is advanced by `nbytes`. - /// - /// # Examples - /// - /// ``` - /// use bytes::BufMut; - /// - /// let mut buf = vec![]; - /// buf.put_uint_ne(0x010203, 3); - /// if cfg!(target_endian = "big") { - /// assert_eq!(buf, b"\x01\x02\x03"); - /// } else { - /// assert_eq!(buf, b"\x03\x02\x01"); - /// } - /// ``` - /// - /// # Panics - /// - /// This function panics if there is not enough remaining capacity in - /// `self` or if `nbytes` is greater than 8. - #[inline] - fn put_uint_ne(&mut self, n: u64, nbytes: usize) { - if cfg!(target_endian = "big") { - self.put_uint(n, nbytes) - } else { - self.put_uint_le(n, nbytes) - } - } - - /// Writes low `nbytes` of a signed integer to `self` in big-endian byte order. - /// - /// The current position is advanced by `nbytes`. - /// - /// # Examples - /// - /// ``` - /// use bytes::BufMut; - /// - /// let mut buf = vec![]; - /// buf.put_int(0x0504010203, 3); - /// assert_eq!(buf, b"\x01\x02\x03"); - /// ``` - /// - /// # Panics - /// - /// This function panics if there is not enough remaining capacity in - /// `self` or if `nbytes` is greater than 8. - #[inline] - fn put_int(&mut self, n: i64, nbytes: usize) { - let start = match mem::size_of_val(&n).checked_sub(nbytes) { - Some(start) => start, - None => panic_does_not_fit(nbytes, mem::size_of_val(&n)), - }; - - self.put_slice(&n.to_be_bytes()[start..]); - } - - /// Writes low `nbytes` of a signed integer to `self` in little-endian byte order. - /// - /// The current position is advanced by `nbytes`. - /// - /// # Examples - /// - /// ``` - /// use bytes::BufMut; - /// - /// let mut buf = vec![]; - /// buf.put_int_le(0x0504010203, 3); - /// assert_eq!(buf, b"\x03\x02\x01"); - /// ``` - /// - /// # Panics - /// - /// This function panics if there is not enough remaining capacity in - /// `self` or if `nbytes` is greater than 8. - #[inline] - fn put_int_le(&mut self, n: i64, nbytes: usize) { - let slice = n.to_le_bytes(); - let slice = match slice.get(..nbytes) { - Some(slice) => slice, - None => panic_does_not_fit(nbytes, slice.len()), - }; - - self.put_slice(slice); - } - - /// Writes low `nbytes` of a signed integer to `self` in native-endian byte order. - /// - /// The current position is advanced by `nbytes`. - /// - /// # Examples - /// - /// ``` - /// use bytes::BufMut; - /// - /// let mut buf = vec![]; - /// buf.put_int_ne(0x010203, 3); - /// if cfg!(target_endian = "big") { - /// assert_eq!(buf, b"\x01\x02\x03"); - /// } else { - /// assert_eq!(buf, b"\x03\x02\x01"); - /// } - /// ``` - /// - /// # Panics - /// - /// This function panics if there is not enough remaining capacity in - /// `self` or if `nbytes` is greater than 8. - #[inline] - fn put_int_ne(&mut self, n: i64, nbytes: usize) { - if cfg!(target_endian = "big") { - self.put_int(n, nbytes) - } else { - self.put_int_le(n, nbytes) - } - } - - /// Writes an IEEE754 single-precision (4 bytes) floating point number to - /// `self` in big-endian byte order. - /// - /// The current position is advanced by 4. - /// - /// # Examples - /// - /// ``` - /// use bytes::BufMut; - /// - /// let mut buf = vec![]; - /// buf.put_f32(1.2f32); - /// assert_eq!(buf, b"\x3F\x99\x99\x9A"); - /// ``` - /// - /// # Panics - /// - /// This function panics if there is not enough remaining capacity in - /// `self`. - #[inline] - fn put_f32(&mut self, n: f32) { - self.put_u32(n.to_bits()); - } - - /// Writes an IEEE754 single-precision (4 bytes) floating point number to - /// `self` in little-endian byte order. - /// - /// The current position is advanced by 4. - /// - /// # Examples - /// - /// ``` - /// use bytes::BufMut; - /// - /// let mut buf = vec![]; - /// buf.put_f32_le(1.2f32); - /// assert_eq!(buf, b"\x9A\x99\x99\x3F"); - /// ``` - /// - /// # Panics - /// - /// This function panics if there is not enough remaining capacity in - /// `self`. - #[inline] - fn put_f32_le(&mut self, n: f32) { - self.put_u32_le(n.to_bits()); - } - - /// Writes an IEEE754 single-precision (4 bytes) floating point number to - /// `self` in native-endian byte order. - /// - /// The current position is advanced by 4. - /// - /// # Examples - /// - /// ``` - /// use bytes::BufMut; - /// - /// let mut buf = vec![]; - /// buf.put_f32_ne(1.2f32); - /// if cfg!(target_endian = "big") { - /// assert_eq!(buf, b"\x3F\x99\x99\x9A"); - /// } else { - /// assert_eq!(buf, b"\x9A\x99\x99\x3F"); - /// } - /// ``` - /// - /// # Panics - /// - /// This function panics if there is not enough remaining capacity in - /// `self`. - #[inline] - fn put_f32_ne(&mut self, n: f32) { - self.put_u32_ne(n.to_bits()); - } - - /// Writes an IEEE754 double-precision (8 bytes) floating point number to - /// `self` in big-endian byte order. - /// - /// The current position is advanced by 8. - /// - /// # Examples - /// - /// ``` - /// use bytes::BufMut; - /// - /// let mut buf = vec![]; - /// buf.put_f64(1.2f64); - /// assert_eq!(buf, b"\x3F\xF3\x33\x33\x33\x33\x33\x33"); - /// ``` - /// - /// # Panics - /// - /// This function panics if there is not enough remaining capacity in - /// `self`. - #[inline] - fn put_f64(&mut self, n: f64) { - self.put_u64(n.to_bits()); - } - - /// Writes an IEEE754 double-precision (8 bytes) floating point number to - /// `self` in little-endian byte order. - /// - /// The current position is advanced by 8. - /// - /// # Examples - /// - /// ``` - /// use bytes::BufMut; - /// - /// let mut buf = vec![]; - /// buf.put_f64_le(1.2f64); - /// assert_eq!(buf, b"\x33\x33\x33\x33\x33\x33\xF3\x3F"); - /// ``` - /// - /// # Panics - /// - /// This function panics if there is not enough remaining capacity in - /// `self`. - #[inline] - fn put_f64_le(&mut self, n: f64) { - self.put_u64_le(n.to_bits()); - } - - /// Writes an IEEE754 double-precision (8 bytes) floating point number to - /// `self` in native-endian byte order. - /// - /// The current position is advanced by 8. - /// - /// # Examples - /// - /// ``` - /// use bytes::BufMut; - /// - /// let mut buf = vec![]; - /// buf.put_f64_ne(1.2f64); - /// if cfg!(target_endian = "big") { - /// assert_eq!(buf, b"\x3F\xF3\x33\x33\x33\x33\x33\x33"); - /// } else { - /// assert_eq!(buf, b"\x33\x33\x33\x33\x33\x33\xF3\x3F"); - /// } - /// ``` - /// - /// # Panics - /// - /// This function panics if there is not enough remaining capacity in - /// `self`. - #[inline] - fn put_f64_ne(&mut self, n: f64) { - self.put_u64_ne(n.to_bits()); - } - - /// Creates an adaptor which can write at most `limit` bytes to `self`. - /// - /// # Examples - /// - /// ``` - /// use bytes::BufMut; - /// - /// let arr = &mut [0u8; 128][..]; - /// assert_eq!(arr.remaining_mut(), 128); - /// - /// let dst = arr.limit(10); - /// assert_eq!(dst.remaining_mut(), 10); - /// ``` - #[inline] - fn limit(self, limit: usize) -> Limit<Self> - where - Self: Sized, - { - limit::new(self, limit) - } - - /// Creates an adaptor which implements the `Write` trait for `self`. - /// - /// This function returns a new value which implements `Write` by adapting - /// the `Write` trait functions to the `BufMut` trait functions. Given that - /// `BufMut` operations are infallible, none of the `Write` functions will - /// return with `Err`. - /// - /// # Examples - /// - /// ``` - /// use bytes::BufMut; - /// use std::io::Write; - /// - /// let mut buf = vec![].writer(); - /// - /// let num = buf.write(&b"hello world"[..]).unwrap(); - /// assert_eq!(11, num); - /// - /// let buf = buf.into_inner(); - /// - /// assert_eq!(*buf, b"hello world"[..]); - /// ``` - #[cfg(feature = "std")] - #[cfg_attr(docsrs, doc(cfg(feature = "std")))] - #[inline] - fn writer(self) -> Writer<Self> - where - Self: Sized, - { - writer::new(self) - } - - /// Creates an adapter which will chain this buffer with another. - /// - /// The returned `BufMut` instance will first write to all bytes from - /// `self`. Afterwards, it will write to `next`. - /// - /// # Examples - /// - /// ``` - /// use bytes::BufMut; - /// - /// let mut a = [0u8; 5]; - /// let mut b = [0u8; 6]; - /// - /// let mut chain = (&mut a[..]).chain_mut(&mut b[..]); - /// - /// chain.put_slice(b"hello world"); - /// - /// assert_eq!(&a[..], b"hello"); - /// assert_eq!(&b[..], b" world"); - /// ``` - #[inline] - fn chain_mut<U: BufMut>(self, next: U) -> Chain<Self, U> - where - Self: Sized, - { - Chain::new(self, next) - } -} - -macro_rules! deref_forward_bufmut { - () => { - #[inline] - fn remaining_mut(&self) -> usize { - (**self).remaining_mut() - } - - #[inline] - fn chunk_mut(&mut self) -> &mut UninitSlice { - (**self).chunk_mut() - } - - #[inline] - unsafe fn advance_mut(&mut self, cnt: usize) { - (**self).advance_mut(cnt) - } - - #[inline] - fn put_slice(&mut self, src: &[u8]) { - (**self).put_slice(src) - } - - #[inline] - fn put_u8(&mut self, n: u8) { - (**self).put_u8(n) - } - - #[inline] - fn put_i8(&mut self, n: i8) { - (**self).put_i8(n) - } - - #[inline] - fn put_u16(&mut self, n: u16) { - (**self).put_u16(n) - } - - #[inline] - fn put_u16_le(&mut self, n: u16) { - (**self).put_u16_le(n) - } - - #[inline] - fn put_u16_ne(&mut self, n: u16) { - (**self).put_u16_ne(n) - } - - #[inline] - fn put_i16(&mut self, n: i16) { - (**self).put_i16(n) - } - - #[inline] - fn put_i16_le(&mut self, n: i16) { - (**self).put_i16_le(n) - } - - #[inline] - fn put_i16_ne(&mut self, n: i16) { - (**self).put_i16_ne(n) - } - - #[inline] - fn put_u32(&mut self, n: u32) { - (**self).put_u32(n) - } - - #[inline] - fn put_u32_le(&mut self, n: u32) { - (**self).put_u32_le(n) - } - - #[inline] - fn put_u32_ne(&mut self, n: u32) { - (**self).put_u32_ne(n) - } - - #[inline] - fn put_i32(&mut self, n: i32) { - (**self).put_i32(n) - } - - #[inline] - fn put_i32_le(&mut self, n: i32) { - (**self).put_i32_le(n) - } - - #[inline] - fn put_i32_ne(&mut self, n: i32) { - (**self).put_i32_ne(n) - } - - #[inline] - fn put_u64(&mut self, n: u64) { - (**self).put_u64(n) - } - - #[inline] - fn put_u64_le(&mut self, n: u64) { - (**self).put_u64_le(n) - } - - #[inline] - fn put_u64_ne(&mut self, n: u64) { - (**self).put_u64_ne(n) - } - - #[inline] - fn put_i64(&mut self, n: i64) { - (**self).put_i64(n) - } - - #[inline] - fn put_i64_le(&mut self, n: i64) { - (**self).put_i64_le(n) - } - - #[inline] - fn put_i64_ne(&mut self, n: i64) { - (**self).put_i64_ne(n) - } - }; -} - -unsafe impl<T: BufMut + ?Sized> BufMut for &mut T { - deref_forward_bufmut!(); -} - -unsafe impl<T: BufMut + ?Sized> BufMut for Box<T> { - deref_forward_bufmut!(); -} - -unsafe impl BufMut for &mut [u8] { - #[inline] - fn remaining_mut(&self) -> usize { - self.len() - } - - #[inline] - fn chunk_mut(&mut self) -> &mut UninitSlice { - UninitSlice::new(self) - } - - #[inline] - unsafe fn advance_mut(&mut self, cnt: usize) { - if self.len() < cnt { - panic_advance(&TryGetError { - requested: cnt, - available: self.len(), - }); - } - - // Lifetime dance taken from `impl Write for &mut [u8]`. - let (_, b) = core::mem::replace(self, &mut []).split_at_mut(cnt); - *self = b; - } - - #[inline] - fn put_slice(&mut self, src: &[u8]) { - if self.len() < src.len() { - panic_advance(&TryGetError { - requested: src.len(), - available: self.len(), - }); - } - - self[..src.len()].copy_from_slice(src); - // SAFETY: We just initialized `src.len()` bytes. - unsafe { self.advance_mut(src.len()) }; - } - - #[inline] - fn put_bytes(&mut self, val: u8, cnt: usize) { - if self.len() < cnt { - panic_advance(&TryGetError { - requested: cnt, - available: self.len(), - }); - } - - // SAFETY: We just checked that the pointer is valid for `cnt` bytes. - unsafe { - ptr::write_bytes(self.as_mut_ptr(), val, cnt); - self.advance_mut(cnt); - } - } -} - -unsafe impl BufMut for &mut [core::mem::MaybeUninit<u8>] { - #[inline] - fn remaining_mut(&self) -> usize { - self.len() - } - - #[inline] - fn chunk_mut(&mut self) -> &mut UninitSlice { - UninitSlice::uninit(self) - } - - #[inline] - unsafe fn advance_mut(&mut self, cnt: usize) { - if self.len() < cnt { - panic_advance(&TryGetError { - requested: cnt, - available: self.len(), - }); - } - - // Lifetime dance taken from `impl Write for &mut [u8]`. - let (_, b) = core::mem::replace(self, &mut []).split_at_mut(cnt); - *self = b; - } - - #[inline] - fn put_slice(&mut self, src: &[u8]) { - if self.len() < src.len() { - panic_advance(&TryGetError { - requested: src.len(), - available: self.len(), - }); - } - - // SAFETY: We just checked that the pointer is valid for `src.len()` bytes. - unsafe { - ptr::copy_nonoverlapping(src.as_ptr(), self.as_mut_ptr().cast(), src.len()); - self.advance_mut(src.len()); - } - } - - #[inline] - fn put_bytes(&mut self, val: u8, cnt: usize) { - if self.len() < cnt { - panic_advance(&TryGetError { - requested: cnt, - available: self.len(), - }); - } - - // SAFETY: We just checked that the pointer is valid for `cnt` bytes. - unsafe { - ptr::write_bytes(self.as_mut_ptr() as *mut u8, val, cnt); - self.advance_mut(cnt); - } - } -} - -unsafe impl BufMut for Vec<u8> { - #[inline] - fn remaining_mut(&self) -> usize { - // A vector can never have more than isize::MAX bytes - core::isize::MAX as usize - self.len() - } - - #[inline] - unsafe fn advance_mut(&mut self, cnt: usize) { - let len = self.len(); - let remaining = self.capacity() - len; - - if remaining < cnt { - panic_advance(&TryGetError { - requested: cnt, - available: remaining, - }); - } - - // Addition will not overflow since the sum is at most the capacity. - self.set_len(len + cnt); - } - - #[inline] - fn chunk_mut(&mut self) -> &mut UninitSlice { - if self.capacity() == self.len() { - self.reserve(64); // Grow the vec - } - - let cap = self.capacity(); - let len = self.len(); - - let ptr = self.as_mut_ptr(); - // SAFETY: Since `ptr` is valid for `cap` bytes, `ptr.add(len)` must be - // valid for `cap - len` bytes. The subtraction will not underflow since - // `len <= cap`. - unsafe { UninitSlice::from_raw_parts_mut(ptr.add(len), cap - len) } - } - - // Specialize these methods so they can skip checking `remaining_mut` - // and `advance_mut`. - #[inline] - fn put<T: super::Buf>(&mut self, mut src: T) - where - Self: Sized, - { - // In case the src isn't contiguous, reserve upfront. - self.reserve(src.remaining()); - - while src.has_remaining() { - let s = src.chunk(); - let l = s.len(); - self.extend_from_slice(s); - src.advance(l); - } - } - - #[inline] - fn put_slice(&mut self, src: &[u8]) { - self.extend_from_slice(src); - } - - #[inline] - fn put_bytes(&mut self, val: u8, cnt: usize) { - // If the addition overflows, then the `resize` will fail. - let new_len = self.len().saturating_add(cnt); - self.resize(new_len, val); - } -} - -// The existence of this function makes the compiler catch if the BufMut -// trait is "object-safe" or not. -fn _assert_trait_object(_b: &dyn BufMut) {} diff --git a/vendor/bytes/src/buf/chain.rs b/vendor/bytes/src/buf/chain.rs deleted file mode 100644 index c8bc36de..00000000 --- a/vendor/bytes/src/buf/chain.rs +++ /dev/null @@ -1,240 +0,0 @@ -use crate::buf::{IntoIter, UninitSlice}; -use crate::{Buf, BufMut}; - -#[cfg(feature = "std")] -use std::io::IoSlice; - -/// A `Chain` sequences two buffers. -/// -/// `Chain` is an adapter that links two underlying buffers and provides a -/// continuous view across both buffers. It is able to sequence either immutable -/// buffers ([`Buf`] values) or mutable buffers ([`BufMut`] values). -/// -/// This struct is generally created by calling [`Buf::chain`]. Please see that -/// function's documentation for more detail. -/// -/// # Examples -/// -/// ``` -/// use bytes::{Bytes, Buf}; -/// -/// let mut buf = (&b"hello "[..]) -/// .chain(&b"world"[..]); -/// -/// let full: Bytes = buf.copy_to_bytes(11); -/// assert_eq!(full[..], b"hello world"[..]); -/// ``` -/// -/// [`Buf::chain`]: Buf::chain -#[derive(Debug)] -pub struct Chain<T, U> { - a: T, - b: U, -} - -impl<T, U> Chain<T, U> { - /// Creates a new `Chain` sequencing the provided values. - pub(crate) fn new(a: T, b: U) -> Chain<T, U> { - Chain { a, b } - } - - /// Gets a reference to the first underlying `Buf`. - /// - /// # Examples - /// - /// ``` - /// use bytes::Buf; - /// - /// let buf = (&b"hello"[..]) - /// .chain(&b"world"[..]); - /// - /// assert_eq!(buf.first_ref()[..], b"hello"[..]); - /// ``` - pub fn first_ref(&self) -> &T { - &self.a - } - - /// Gets a mutable reference to the first underlying `Buf`. - /// - /// # Examples - /// - /// ``` - /// use bytes::Buf; - /// - /// let mut buf = (&b"hello"[..]) - /// .chain(&b"world"[..]); - /// - /// buf.first_mut().advance(1); - /// - /// let full = buf.copy_to_bytes(9); - /// assert_eq!(full, b"elloworld"[..]); - /// ``` - pub fn first_mut(&mut self) -> &mut T { - &mut self.a - } - - /// Gets a reference to the last underlying `Buf`. - /// - /// # Examples - /// - /// ``` - /// use bytes::Buf; - /// - /// let buf = (&b"hello"[..]) - /// .chain(&b"world"[..]); - /// - /// assert_eq!(buf.last_ref()[..], b"world"[..]); - /// ``` - pub fn last_ref(&self) -> &U { - &self.b - } - - /// Gets a mutable reference to the last underlying `Buf`. - /// - /// # Examples - /// - /// ``` - /// use bytes::Buf; - /// - /// let mut buf = (&b"hello "[..]) - /// .chain(&b"world"[..]); - /// - /// buf.last_mut().advance(1); - /// - /// let full = buf.copy_to_bytes(10); - /// assert_eq!(full, b"hello orld"[..]); - /// ``` - pub fn last_mut(&mut self) -> &mut U { - &mut self.b - } - - /// Consumes this `Chain`, returning the underlying values. - /// - /// # Examples - /// - /// ``` - /// use bytes::Buf; - /// - /// let chain = (&b"hello"[..]) - /// .chain(&b"world"[..]); - /// - /// let (first, last) = chain.into_inner(); - /// assert_eq!(first[..], b"hello"[..]); - /// assert_eq!(last[..], b"world"[..]); - /// ``` - pub fn into_inner(self) -> (T, U) { - (self.a, self.b) - } -} - -impl<T, U> Buf for Chain<T, U> -where - T: Buf, - U: Buf, -{ - fn remaining(&self) -> usize { - self.a.remaining().saturating_add(self.b.remaining()) - } - - fn chunk(&self) -> &[u8] { - if self.a.has_remaining() { - self.a.chunk() - } else { - self.b.chunk() - } - } - - fn advance(&mut self, mut cnt: usize) { - let a_rem = self.a.remaining(); - - if a_rem != 0 { - if a_rem >= cnt { - self.a.advance(cnt); - return; - } - - // Consume what is left of a - self.a.advance(a_rem); - - cnt -= a_rem; - } - - self.b.advance(cnt); - } - - #[cfg(feature = "std")] - fn 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..]); - n - } - - fn copy_to_bytes(&mut self, len: usize) -> crate::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> -where - T: BufMut, - U: BufMut, -{ - fn remaining_mut(&self) -> usize { - self.a - .remaining_mut() - .saturating_add(self.b.remaining_mut()) - } - - fn chunk_mut(&mut self) -> &mut UninitSlice { - if self.a.has_remaining_mut() { - self.a.chunk_mut() - } else { - self.b.chunk_mut() - } - } - - unsafe fn advance_mut(&mut self, mut cnt: usize) { - let a_rem = self.a.remaining_mut(); - - if a_rem != 0 { - if a_rem >= cnt { - self.a.advance_mut(cnt); - return; - } - - // Consume what is left of a - self.a.advance_mut(a_rem); - - cnt -= a_rem; - } - - self.b.advance_mut(cnt); - } -} - -impl<T, U> IntoIterator for Chain<T, U> -where - T: Buf, - U: Buf, -{ - type Item = u8; - type IntoIter = IntoIter<Chain<T, U>>; - - fn into_iter(self) -> Self::IntoIter { - IntoIter::new(self) - } -} diff --git a/vendor/bytes/src/buf/iter.rs b/vendor/bytes/src/buf/iter.rs deleted file mode 100644 index 74f9b991..00000000 --- a/vendor/bytes/src/buf/iter.rs +++ /dev/null @@ -1,127 +0,0 @@ -use crate::Buf; - -/// Iterator over the bytes contained by the buffer. -/// -/// # Examples -/// -/// Basic usage: -/// -/// ``` -/// use bytes::Bytes; -/// -/// let buf = Bytes::from(&b"abc"[..]); -/// let mut iter = buf.into_iter(); -/// -/// assert_eq!(iter.next(), Some(b'a')); -/// assert_eq!(iter.next(), Some(b'b')); -/// assert_eq!(iter.next(), Some(b'c')); -/// assert_eq!(iter.next(), None); -/// ``` -#[derive(Debug)] -pub struct IntoIter<T> { - inner: T, -} - -impl<T> IntoIter<T> { - /// Creates an iterator over the bytes contained by the buffer. - /// - /// # Examples - /// - /// ``` - /// use bytes::Bytes; - /// - /// let buf = Bytes::from_static(b"abc"); - /// let mut iter = buf.into_iter(); - /// - /// assert_eq!(iter.next(), Some(b'a')); - /// assert_eq!(iter.next(), Some(b'b')); - /// assert_eq!(iter.next(), Some(b'c')); - /// assert_eq!(iter.next(), None); - /// ``` - pub fn new(inner: T) -> IntoIter<T> { - IntoIter { inner } - } - - /// Consumes this `IntoIter`, returning the underlying value. - /// - /// # Examples - /// - /// ```rust - /// use bytes::{Buf, Bytes}; - /// - /// let buf = Bytes::from(&b"abc"[..]); - /// let mut iter = buf.into_iter(); - /// - /// assert_eq!(iter.next(), Some(b'a')); - /// - /// let buf = iter.into_inner(); - /// assert_eq!(2, buf.remaining()); - /// ``` - pub fn into_inner(self) -> T { - self.inner - } - - /// Gets a reference to the underlying `Buf`. - /// - /// It is inadvisable to directly read from the underlying `Buf`. - /// - /// # Examples - /// - /// ```rust - /// use bytes::{Buf, Bytes}; - /// - /// let buf = Bytes::from(&b"abc"[..]); - /// let mut iter = buf.into_iter(); - /// - /// assert_eq!(iter.next(), Some(b'a')); - /// - /// assert_eq!(2, iter.get_ref().remaining()); - /// ``` - pub fn get_ref(&self) -> &T { - &self.inner - } - - /// Gets a mutable reference to the underlying `Buf`. - /// - /// It is inadvisable to directly read from the underlying `Buf`. - /// - /// # Examples - /// - /// ```rust - /// use bytes::{Buf, BytesMut}; - /// - /// let buf = BytesMut::from(&b"abc"[..]); - /// let mut iter = buf.into_iter(); - /// - /// assert_eq!(iter.next(), Some(b'a')); - /// - /// iter.get_mut().advance(1); - /// - /// assert_eq!(iter.next(), Some(b'c')); - /// ``` - pub fn get_mut(&mut self) -> &mut T { - &mut self.inner - } -} - -impl<T: Buf> Iterator for IntoIter<T> { - type Item = u8; - - fn next(&mut self) -> Option<u8> { - if !self.inner.has_remaining() { - return None; - } - - let b = self.inner.chunk()[0]; - self.inner.advance(1); - - Some(b) - } - - fn size_hint(&self) -> (usize, Option<usize>) { - let rem = self.inner.remaining(); - (rem, Some(rem)) - } -} - -impl<T: Buf> ExactSizeIterator for IntoIter<T> {} diff --git a/vendor/bytes/src/buf/limit.rs b/vendor/bytes/src/buf/limit.rs deleted file mode 100644 index b422be53..00000000 --- a/vendor/bytes/src/buf/limit.rs +++ /dev/null @@ -1,75 +0,0 @@ -use crate::buf::UninitSlice; -use crate::BufMut; - -use core::cmp; - -/// A `BufMut` adapter which limits the amount of bytes that can be written -/// to an underlying buffer. -#[derive(Debug)] -pub struct Limit<T> { - inner: T, - limit: usize, -} - -pub(super) fn new<T>(inner: T, limit: usize) -> Limit<T> { - Limit { inner, limit } -} - -impl<T> Limit<T> { - /// Consumes this `Limit`, returning the underlying value. - pub fn into_inner(self) -> T { - self.inner - } - - /// Gets a reference to the underlying `BufMut`. - /// - /// It is inadvisable to directly write to the underlying `BufMut`. - pub fn get_ref(&self) -> &T { - &self.inner - } - - /// Gets a mutable reference to the underlying `BufMut`. - /// - /// It is inadvisable to directly write to the underlying `BufMut`. - pub fn get_mut(&mut self) -> &mut T { - &mut self.inner - } - - /// Returns the maximum number of bytes that can be written - /// - /// # Note - /// - /// If the inner `BufMut` has fewer bytes than indicated by this method then - /// that is the actual number of available bytes. - pub fn limit(&self) -> usize { - self.limit - } - - /// Sets the maximum number of bytes that can be written. - /// - /// # Note - /// - /// If the inner `BufMut` has fewer bytes than `lim` then that is the actual - /// number of available bytes. - pub fn set_limit(&mut self, lim: usize) { - self.limit = lim - } -} - -unsafe impl<T: BufMut> BufMut for Limit<T> { - fn remaining_mut(&self) -> usize { - cmp::min(self.inner.remaining_mut(), self.limit) - } - - fn chunk_mut(&mut self) -> &mut UninitSlice { - let bytes = self.inner.chunk_mut(); - let end = cmp::min(bytes.len(), self.limit); - &mut bytes[..end] - } - - unsafe fn advance_mut(&mut self, cnt: usize) { - assert!(cnt <= self.limit); - self.inner.advance_mut(cnt); - self.limit -= cnt; - } -} diff --git a/vendor/bytes/src/buf/mod.rs b/vendor/bytes/src/buf/mod.rs deleted file mode 100644 index 1bf0a47e..00000000 --- a/vendor/bytes/src/buf/mod.rs +++ /dev/null @@ -1,39 +0,0 @@ -//! Utilities for working with buffers. -//! -//! A buffer is any structure that contains a sequence of bytes. The bytes may -//! or may not be stored in contiguous memory. This module contains traits used -//! to abstract over buffers as well as utilities for working with buffer types. -//! -//! # `Buf`, `BufMut` -//! -//! These are the two foundational traits for abstractly working with buffers. -//! They can be thought as iterators for byte structures. They offer additional -//! performance over `Iterator` by providing an API optimized for byte slices. -//! -//! See [`Buf`] and [`BufMut`] for more details. -//! -//! [rope]: https://en.wikipedia.org/wiki/Rope_(data_structure) - -mod buf_impl; -mod buf_mut; -mod chain; -mod iter; -mod limit; -#[cfg(feature = "std")] -mod reader; -mod take; -mod uninit_slice; -mod vec_deque; -#[cfg(feature = "std")] -mod writer; - -pub use self::buf_impl::Buf; -pub use self::buf_mut::BufMut; -pub use self::chain::Chain; -pub use self::iter::IntoIter; -pub use self::limit::Limit; -pub use self::take::Take; -pub use self::uninit_slice::UninitSlice; - -#[cfg(feature = "std")] -pub use self::{reader::Reader, writer::Writer}; diff --git a/vendor/bytes/src/buf/reader.rs b/vendor/bytes/src/buf/reader.rs deleted file mode 100644 index 52149495..00000000 --- a/vendor/bytes/src/buf/reader.rs +++ /dev/null @@ -1,81 +0,0 @@ -use crate::Buf; - -use std::{cmp, io}; - -/// A `Buf` adapter which implements `io::Read` for the inner value. -/// -/// This struct is generally created by calling `reader()` on `Buf`. See -/// documentation of [`reader()`](Buf::reader) for more -/// details. -#[derive(Debug)] -pub struct Reader<B> { - buf: B, -} - -pub fn new<B>(buf: B) -> Reader<B> { - Reader { buf } -} - -impl<B: Buf> Reader<B> { - /// Gets a reference to the underlying `Buf`. - /// - /// It is inadvisable to directly read from the underlying `Buf`. - /// - /// # Examples - /// - /// ```rust - /// use bytes::Buf; - /// - /// let buf = b"hello world".reader(); - /// - /// assert_eq!(b"hello world", buf.get_ref()); - /// ``` - pub fn get_ref(&self) -> &B { - &self.buf - } - - /// Gets a mutable reference to the underlying `Buf`. - /// - /// It is inadvisable to directly read from the underlying `Buf`. - pub fn get_mut(&mut self) -> &mut B { - &mut self.buf - } - - /// Consumes this `Reader`, returning the underlying value. - /// - /// # Examples - /// - /// ```rust - /// use bytes::Buf; - /// use std::io; - /// - /// let mut buf = b"hello world".reader(); - /// let mut dst = vec![]; - /// - /// io::copy(&mut buf, &mut dst).unwrap(); - /// - /// let buf = buf.into_inner(); - /// assert_eq!(0, buf.remaining()); - /// ``` - pub fn into_inner(self) -> B { - self.buf - } -} - -impl<B: Buf + Sized> io::Read for Reader<B> { - fn read(&mut self, dst: &mut [u8]) -> io::Result<usize> { - let len = cmp::min(self.buf.remaining(), dst.len()); - - Buf::copy_to_slice(&mut self.buf, &mut dst[0..len]); - Ok(len) - } -} - -impl<B: Buf + Sized> io::BufRead for Reader<B> { - fn fill_buf(&mut self) -> io::Result<&[u8]> { - Ok(self.buf.chunk()) - } - fn consume(&mut self, amt: usize) { - self.buf.advance(amt) - } -} diff --git a/vendor/bytes/src/buf/take.rs b/vendor/bytes/src/buf/take.rs deleted file mode 100644 index acfeef6e..00000000 --- a/vendor/bytes/src/buf/take.rs +++ /dev/null @@ -1,204 +0,0 @@ -use crate::Buf; - -use core::cmp; - -#[cfg(feature = "std")] -use std::io::IoSlice; - -/// 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. -#[derive(Debug)] -pub struct Take<T> { - inner: T, - limit: usize, -} - -pub fn new<T>(inner: T, limit: usize) -> Take<T> { - Take { inner, limit } -} - -impl<T> Take<T> { - /// Consumes this `Take`, returning the underlying value. - /// - /// # Examples - /// - /// ```rust - /// use bytes::{Buf, BufMut}; - /// - /// let mut buf = b"hello world".take(2); - /// let mut dst = vec![]; - /// - /// dst.put(&mut buf); - /// assert_eq!(*dst, b"he"[..]); - /// - /// let mut buf = buf.into_inner(); - /// - /// dst.clear(); - /// dst.put(&mut buf); - /// assert_eq!(*dst, b"llo world"[..]); - /// ``` - pub fn into_inner(self) -> T { - self.inner - } - - /// Gets a reference to the underlying `Buf`. - /// - /// It is inadvisable to directly read from the underlying `Buf`. - /// - /// # Examples - /// - /// ```rust - /// use bytes::Buf; - /// - /// let buf = b"hello world".take(2); - /// - /// assert_eq!(11, buf.get_ref().remaining()); - /// ``` - pub fn get_ref(&self) -> &T { - &self.inner - } - - /// Gets a mutable reference to the underlying `Buf`. - /// - /// It is inadvisable to directly read from the underlying `Buf`. - /// - /// # Examples - /// - /// ```rust - /// use bytes::{Buf, BufMut}; - /// - /// let mut buf = b"hello world".take(2); - /// let mut dst = vec![]; - /// - /// buf.get_mut().advance(2); - /// - /// dst.put(&mut buf); - /// assert_eq!(*dst, b"ll"[..]); - /// ``` - pub fn get_mut(&mut self) -> &mut T { - &mut self.inner - } - - /// Returns the maximum number of bytes that can be read. - /// - /// # Note - /// - /// If the inner `Buf` has fewer bytes than indicated by this method then - /// that is the actual number of available bytes. - /// - /// # Examples - /// - /// ```rust - /// use bytes::Buf; - /// - /// let mut buf = b"hello world".take(2); - /// - /// assert_eq!(2, buf.limit()); - /// assert_eq!(b'h', buf.get_u8()); - /// assert_eq!(1, buf.limit()); - /// ``` - pub fn limit(&self) -> usize { - self.limit - } - - /// Sets the maximum number of bytes that can be read. - /// - /// # Note - /// - /// If the inner `Buf` has fewer bytes than `lim` then that is the actual - /// number of available bytes. - /// - /// # Examples - /// - /// ```rust - /// use bytes::{Buf, BufMut}; - /// - /// let mut buf = b"hello world".take(2); - /// let mut dst = vec![]; - /// - /// dst.put(&mut buf); - /// assert_eq!(*dst, b"he"[..]); - /// - /// dst.clear(); - /// - /// buf.set_limit(3); - /// dst.put(&mut buf); - /// assert_eq!(*dst, b"llo"[..]); - /// ``` - pub fn set_limit(&mut self, lim: usize) { - self.limit = lim - } -} - -impl<T: Buf> Buf for Take<T> { - fn remaining(&self) -> usize { - cmp::min(self.inner.remaining(), self.limit) - } - - fn chunk(&self) -> &[u8] { - let bytes = self.inner.chunk(); - &bytes[..cmp::min(bytes.len(), self.limit)] - } - - fn advance(&mut self, cnt: usize) { - assert!(cnt <= self.limit); - self.inner.advance(cnt); - self.limit -= cnt; - } - - fn copy_to_bytes(&mut self, len: usize) -> crate::Bytes { - assert!(len <= self.remaining(), "`len` greater than remaining"); - - let r = self.inner.copy_to_bytes(len); - self.limit -= len; - r - } - - #[cfg(feature = "std")] - fn chunks_vectored<'a>(&'a self, dst: &mut [IoSlice<'a>]) -> usize { - if self.limit == 0 { - return 0; - } - - const LEN: usize = 16; - let mut slices: [IoSlice<'a>; LEN] = [ - IoSlice::new(&[]), - IoSlice::new(&[]), - IoSlice::new(&[]), - IoSlice::new(&[]), - IoSlice::new(&[]), - IoSlice::new(&[]), - IoSlice::new(&[]), - IoSlice::new(&[]), - IoSlice::new(&[]), - IoSlice::new(&[]), - IoSlice::new(&[]), - IoSlice::new(&[]), - IoSlice::new(&[]), - IoSlice::new(&[]), - IoSlice::new(&[]), - IoSlice::new(&[]), - ]; - - let cnt = self - .inner - .chunks_vectored(&mut slices[..dst.len().min(LEN)]); - let mut limit = self.limit; - for (i, (dst, slice)) in dst[..cnt].iter_mut().zip(slices.iter()).enumerate() { - if let Some(buf) = slice.get(..limit) { - // SAFETY: We could do this safely with `IoSlice::advance` if we had a larger MSRV. - let buf = unsafe { std::mem::transmute::<&[u8], &'a [u8]>(buf) }; - *dst = IoSlice::new(buf); - return i + 1; - } else { - // SAFETY: We could do this safely with `IoSlice::advance` if we had a larger MSRV. - let buf = unsafe { std::mem::transmute::<&[u8], &'a [u8]>(slice) }; - *dst = IoSlice::new(buf); - limit -= slice.len(); - } - } - cnt - } -} diff --git a/vendor/bytes/src/buf/uninit_slice.rs b/vendor/bytes/src/buf/uninit_slice.rs deleted file mode 100644 index aea096ae..00000000 --- a/vendor/bytes/src/buf/uninit_slice.rs +++ /dev/null @@ -1,257 +0,0 @@ -use core::fmt; -use core::mem::MaybeUninit; -use core::ops::{ - Index, IndexMut, Range, RangeFrom, RangeFull, RangeInclusive, RangeTo, RangeToInclusive, -}; - -/// Uninitialized byte slice. -/// -/// Returned by `BufMut::chunk_mut()`, the referenced byte slice may be -/// uninitialized. The wrapper provides safe access without introducing -/// undefined behavior. -/// -/// The safety invariants of this wrapper are: -/// -/// 1. Reading from an `UninitSlice` is undefined behavior. -/// 2. Writing uninitialized bytes to an `UninitSlice` is undefined behavior. -/// -/// The difference between `&mut UninitSlice` and `&mut [MaybeUninit<u8>]` is -/// that it is possible in safe code to write uninitialized bytes to an -/// `&mut [MaybeUninit<u8>]`, which this type prohibits. -#[repr(transparent)] -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 - /// - /// The caller must ensure that `ptr` references a valid memory region owned - /// by the caller representing a byte slice for the duration of `'a`. - /// - /// # Examples - /// - /// ``` - /// use bytes::buf::UninitSlice; - /// - /// let bytes = b"hello world".to_vec(); - /// let ptr = bytes.as_ptr() as *mut _; - /// let len = bytes.len(); - /// - /// 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) - } - - /// Write a single byte at the specified offset. - /// - /// # Panics - /// - /// The function panics if `index` is out of bounds. - /// - /// # Examples - /// - /// ``` - /// use bytes::buf::UninitSlice; - /// - /// let mut data = [b'f', b'o', b'o']; - /// let slice = unsafe { UninitSlice::from_raw_parts_mut(data.as_mut_ptr(), 3) }; - /// - /// slice.write_byte(0, b'b'); - /// - /// 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`. - /// - /// The length of `src` must be the same as `self`. - /// - /// # Panics - /// - /// The function panics if `src` has a different length than `self`. - /// - /// # Examples - /// - /// ``` - /// use bytes::buf::UninitSlice; - /// - /// let mut data = [b'f', b'o', b'o']; - /// let slice = unsafe { UninitSlice::from_raw_parts_mut(data.as_mut_ptr(), 3) }; - /// - /// slice.copy_from_slice(b"bar"); - /// - /// assert_eq!(b"bar", &data[..]); - /// ``` - #[inline] - pub fn copy_from_slice(&mut self, src: &[u8]) { - use core::ptr; - - assert_eq!(self.len(), src.len()); - - unsafe { - ptr::copy_nonoverlapping(src.as_ptr(), self.as_mut_ptr(), self.len()); - } - } - - /// Return a raw pointer to the slice's buffer. - /// - /// # Safety - /// - /// The caller **must not** read from the referenced memory and **must not** - /// write **uninitialized** bytes to the slice either. - /// - /// # Examples - /// - /// ``` - /// use bytes::BufMut; - /// - /// let mut data = [0, 1, 2]; - /// let mut slice = &mut data[..]; - /// let ptr = BufMut::chunk_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 - /// - /// ``` - /// use bytes::BufMut; - /// - /// let mut data = [0, 1, 2]; - /// let mut slice = &mut data[..]; - /// let len = BufMut::chunk_mut(&mut slice).len(); - /// - /// assert_eq!(len, 3); - /// ``` - #[inline] - pub fn len(&self) -> usize { - self.0.len() - } -} - -impl fmt::Debug for UninitSlice { - fn fmt(&self, fmt: &mut fmt::Formatter<'_>) -> fmt::Result { - fmt.debug_struct("UninitSlice[...]").finish() - } -} - -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]) - } - } - - impl IndexMut<$t> for UninitSlice { - #[inline] - fn index_mut(&mut self, index: $t) -> &mut UninitSlice { - UninitSlice::uninit(&mut self.0[index]) - } - } - )* - }; -} - -impl_index!( - Range<usize>, - RangeFrom<usize>, - RangeFull, - RangeInclusive<usize>, - RangeTo<usize>, - RangeToInclusive<usize> -); diff --git a/vendor/bytes/src/buf/vec_deque.rs b/vendor/bytes/src/buf/vec_deque.rs deleted file mode 100644 index 55d5636b..00000000 --- a/vendor/bytes/src/buf/vec_deque.rs +++ /dev/null @@ -1,40 +0,0 @@ -use alloc::collections::VecDeque; -#[cfg(feature = "std")] -use std::io; - -use super::Buf; - -impl Buf for VecDeque<u8> { - fn remaining(&self) -> usize { - self.len() - } - - fn chunk(&self) -> &[u8] { - let (s1, s2) = self.as_slices(); - if s1.is_empty() { - s2 - } else { - s1 - } - } - - #[cfg(feature = "std")] - fn chunks_vectored<'a>(&'a self, dst: &mut [io::IoSlice<'a>]) -> usize { - if self.is_empty() || dst.is_empty() { - return 0; - } - - let (s1, s2) = self.as_slices(); - dst[0] = io::IoSlice::new(s1); - if s2.is_empty() || dst.len() == 1 { - return 1; - } - - dst[1] = io::IoSlice::new(s2); - 2 - } - - fn advance(&mut self, cnt: usize) { - self.drain(..cnt); - } -} diff --git a/vendor/bytes/src/buf/writer.rs b/vendor/bytes/src/buf/writer.rs deleted file mode 100644 index e72348f4..00000000 --- a/vendor/bytes/src/buf/writer.rs +++ /dev/null @@ -1,88 +0,0 @@ -use crate::BufMut; - -use std::{cmp, io}; - -/// A `BufMut` adapter which implements `io::Write` for the inner value. -/// -/// This struct is generally created by calling `writer()` on `BufMut`. See -/// documentation of [`writer()`](BufMut::writer) for more -/// details. -#[derive(Debug)] -pub struct Writer<B> { - buf: B, -} - -pub fn new<B>(buf: B) -> Writer<B> { - Writer { buf } -} - -impl<B: BufMut> Writer<B> { - /// Gets a reference to the underlying `BufMut`. - /// - /// It is inadvisable to directly write to the underlying `BufMut`. - /// - /// # Examples - /// - /// ```rust - /// use bytes::BufMut; - /// - /// let buf = Vec::with_capacity(1024).writer(); - /// - /// assert_eq!(1024, buf.get_ref().capacity()); - /// ``` - pub fn get_ref(&self) -> &B { - &self.buf - } - - /// Gets a mutable reference to the underlying `BufMut`. - /// - /// It is inadvisable to directly write to the underlying `BufMut`. - /// - /// # Examples - /// - /// ```rust - /// use bytes::BufMut; - /// - /// let mut buf = vec![].writer(); - /// - /// buf.get_mut().reserve(1024); - /// - /// assert_eq!(1024, buf.get_ref().capacity()); - /// ``` - pub fn get_mut(&mut self) -> &mut B { - &mut self.buf - } - - /// Consumes this `Writer`, returning the underlying value. - /// - /// # Examples - /// - /// ```rust - /// use bytes::BufMut; - /// use std::io; - /// - /// let mut buf = vec![].writer(); - /// let mut src = &b"hello world"[..]; - /// - /// io::copy(&mut src, &mut buf).unwrap(); - /// - /// let buf = buf.into_inner(); - /// assert_eq!(*buf, b"hello world"[..]); - /// ``` - pub fn into_inner(self) -> B { - self.buf - } -} - -impl<B: BufMut + Sized> io::Write for Writer<B> { - fn write(&mut self, src: &[u8]) -> io::Result<usize> { - let n = cmp::min(self.buf.remaining_mut(), src.len()); - - self.buf.put_slice(&src[..n]); - Ok(n) - } - - fn flush(&mut self) -> io::Result<()> { - Ok(()) - } -} diff --git a/vendor/bytes/src/bytes.rs b/vendor/bytes/src/bytes.rs deleted file mode 100644 index cdb6ea55..00000000 --- a/vendor/bytes/src/bytes.rs +++ /dev/null @@ -1,1680 +0,0 @@ -use core::iter::FromIterator; -use core::mem::{self, ManuallyDrop}; -use core::ops::{Deref, RangeBounds}; -use core::ptr::NonNull; -use core::{cmp, fmt, hash, ptr, slice, usize}; - -use alloc::{ - alloc::{dealloc, Layout}, - 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}; - -/// A cheaply cloneable and sliceable chunk of contiguous memory. -/// -/// `Bytes` is an efficient container for storing and operating on contiguous -/// slices of memory. It is intended for use primarily in networking code, but -/// could have applications elsewhere as well. -/// -/// `Bytes` values facilitate zero-copy network programming by allowing multiple -/// `Bytes` objects to point to the same underlying memory. -/// -/// `Bytes` does not have a single implementation. It is an interface, whose -/// exact behavior is implemented through dynamic dispatch in several underlying -/// implementations of `Bytes`. -/// -/// 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. -/// -/// ``` -/// use bytes::Bytes; -/// -/// let mut mem = Bytes::from("Hello world"); -/// let a = mem.slice(0..5); -/// -/// assert_eq!(a, "Hello"); -/// -/// let b = mem.split_to(6); -/// -/// assert_eq!(mem, "world"); -/// assert_eq!(b, "Hello "); -/// ``` -/// -/// # Memory layout -/// -/// The `Bytes` struct itself is fairly small, limited to 4 `usize` fields used -/// to track information about which segment of the underlying memory the -/// `Bytes` handle has access to. -/// -/// `Bytes` keeps both a pointer to the shared state containing the full memory -/// slice and a pointer to the start of the region visible by the handle. -/// `Bytes` also tracks the length of its view into the memory. -/// -/// # Sharing -/// -/// `Bytes` contains a vtable, which allows implementations of `Bytes` to define -/// how sharing/cloning 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. -/// -/// 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. -/// -/// Due to this mechanism, multiple `Bytes` instances may point to the same -/// shared memory region. -/// Each `Bytes` instance can point to different sections within that -/// memory region, and `Bytes` instances may or may not have overlapping views -/// into the memory. -/// -/// The following diagram visualizes a scenario where 2 `Bytes` instances make -/// use of an `Arc`-based backing storage, and provide access to different views: -/// -/// ```text -/// -/// Arc ptrs ┌─────────┐ -/// ________________________ / │ Bytes 2 │ -/// / └─────────┘ -/// / ┌───────────┐ | | -/// |_________/ │ Bytes 1 │ | | -/// | └───────────┘ | | -/// | | | ___/ data | tail -/// | data | tail |/ | -/// v v v v -/// ┌─────┬─────┬───────────┬───────────────┬─────┐ -/// │ Arc │ │ │ │ │ -/// └─────┴─────┴───────────┴───────────────┴─────┘ -/// ``` -pub struct Bytes { - ptr: *const u8, - len: usize, - // inlined "trait object" - data: AtomicPtr<()>, - vtable: &'static Vtable, -} - -pub(crate) struct Vtable { - /// fn(data, ptr, len) - pub clone: unsafe fn(&AtomicPtr<()>, *const u8, usize) -> Bytes, - /// fn(data, ptr, len) - /// - /// 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), -} - -impl Bytes { - /// Creates a new empty `Bytes`. - /// - /// This will not allocate and the returned `Bytes` handle will be empty. - /// - /// # Examples - /// - /// ``` - /// use bytes::Bytes; - /// - /// let b = Bytes::new(); - /// assert_eq!(&b[..], b""); - /// ``` - #[inline] - #[cfg(not(all(loom, test)))] - pub const fn new() -> Self { - // 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 { - const EMPTY: &[u8] = &[]; - Bytes::from_static(EMPTY) - } - - /// Creates a new `Bytes` from a static slice. - /// - /// The returned `Bytes` will point directly to the static slice. There is - /// no allocating or copying. - /// - /// # Examples - /// - /// ``` - /// use bytes::Bytes; - /// - /// let b = Bytes::from_static(b"hello"); - /// assert_eq!(&b[..], b"hello"); - /// ``` - #[inline] - #[cfg(not(all(loom, test)))] - pub const fn from_static(bytes: &'static [u8]) -> Self { - Bytes { - ptr: bytes.as_ptr(), - len: bytes.len(), - data: AtomicPtr::new(ptr::null_mut()), - vtable: &STATIC_VTABLE, - } - } - - /// Creates a new `Bytes` from a static slice. - #[cfg(all(loom, test))] - pub fn from_static(bytes: &'static [u8]) -> Self { - Bytes { - ptr: bytes.as_ptr(), - len: bytes.len(), - data: AtomicPtr::new(ptr::null_mut()), - vtable: &STATIC_VTABLE, - } - } - - /// 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, - } - } - - /// Create [Bytes] with a buffer whose lifetime is controlled - /// via an explicit owner. - /// - /// A common use case is to zero-copy construct from mapped memory. - /// - /// ``` - /// # struct File; - /// # - /// # impl File { - /// # pub fn open(_: &str) -> Result<Self, ()> { - /// # Ok(Self) - /// # } - /// # } - /// # - /// # mod memmap2 { - /// # pub struct Mmap; - /// # - /// # impl Mmap { - /// # pub unsafe fn map(_file: &super::File) -> Result<Self, ()> { - /// # Ok(Self) - /// # } - /// # } - /// # - /// # impl AsRef<[u8]> for Mmap { - /// # fn as_ref(&self) -> &[u8] { - /// # b"buf" - /// # } - /// # } - /// # } - /// use bytes::Bytes; - /// use memmap2::Mmap; - /// - /// # fn main() -> Result<(), ()> { - /// let file = File::open("upload_bundle.tar.gz")?; - /// let mmap = unsafe { Mmap::map(&file) }?; - /// let b = Bytes::from_owner(mmap); - /// # Ok(()) - /// # } - /// ``` - /// - /// The `owner` will be transferred to the constructed [Bytes] object, which - /// will ensure it is dropped once all remaining clones of the constructed - /// object are dropped. The owner will then be responsible for dropping the - /// specified region of memory as part of its [Drop] implementation. - /// - /// Note that converting [Bytes] constructed from an owner into a [BytesMut] - /// will always create a deep copy of the buffer into newly allocated memory. - pub fn from_owner<T>(owner: T) -> Self - where - T: AsRef<[u8]> + Send + 'static, - { - // Safety & Miri: - // The ownership of `owner` is first transferred to the `Owned` wrapper and `Bytes` object. - // This ensures that the owner is pinned in memory, allowing us to call `.as_ref()` safely - // since the lifetime of the owner is controlled by the lifetime of the new `Bytes` object, - // and the lifetime of the resulting borrowed `&[u8]` matches that of the owner. - // Note that this remains safe so long as we only call `.as_ref()` once. - // - // There are some additional special considerations here: - // * We rely on Bytes's Drop impl to clean up memory should `.as_ref()` panic. - // * Setting the `ptr` and `len` on the bytes object last (after moving the owner to - // Bytes) allows Miri checks to pass since it avoids obtaining the `&[u8]` slice - // from a stack-owned Box. - // More details on this: https://github.com/tokio-rs/bytes/pull/742/#discussion_r1813375863 - // and: https://github.com/tokio-rs/bytes/pull/742/#discussion_r1813316032 - - let owned = Box::into_raw(Box::new(Owned { - lifetime: OwnedLifetime { - ref_cnt: AtomicUsize::new(1), - drop: owned_box_and_drop::<T>, - }, - owner, - })); - - let mut ret = Bytes { - ptr: NonNull::dangling().as_ptr(), - len: 0, - data: AtomicPtr::new(owned.cast()), - vtable: &OWNED_VTABLE, - }; - - let buf = unsafe { &*owned }.owner.as_ref(); - ret.ptr = buf.as_ptr(); - ret.len = buf.len(); - - ret - } - - /// Returns the number of bytes contained in this `Bytes`. - /// - /// # Examples - /// - /// ``` - /// use bytes::Bytes; - /// - /// let b = Bytes::from(&b"hello"[..]); - /// assert_eq!(b.len(), 5); - /// ``` - #[inline] - pub const fn len(&self) -> usize { - self.len - } - - /// Returns true if the `Bytes` has a length of 0. - /// - /// # Examples - /// - /// ``` - /// use bytes::Bytes; - /// - /// let b = Bytes::new(); - /// assert!(b.is_empty()); - /// ``` - #[inline] - pub const fn is_empty(&self) -> bool { - self.len == 0 - } - - /// Returns true if this is the only reference to the data and - /// `Into<BytesMut>` would avoid cloning the underlying buffer. - /// - /// Always returns false if the data is backed by a [static slice](Bytes::from_static), - /// or an [owner](Bytes::from_owner). - /// - /// 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() - } - - /// Returns a slice of self for the provided range. - /// - /// This will increment the reference count for the underlying memory and - /// return a new `Bytes` handle set to the slice. - /// - /// This operation is `O(1)`. - /// - /// # Examples - /// - /// ``` - /// use bytes::Bytes; - /// - /// let a = Bytes::from(&b"hello world"[..]); - /// let b = a.slice(2..5); - /// - /// assert_eq!(&b[..], b"llo"); - /// ``` - /// - /// # Panics - /// - /// Requires that `begin <= end` and `end <= self.len()`, otherwise slicing - /// will panic. - pub fn slice(&self, range: impl RangeBounds<usize>) -> Self { - 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::Unbounded => 0, - }; - - let end = match range.end_bound() { - Bound::Included(&n) => n.checked_add(1).expect("out of range"), - Bound::Excluded(&n) => n, - Bound::Unbounded => len, - }; - - assert!( - begin <= end, - "range start must not be greater than end: {:?} <= {:?}", - begin, - end, - ); - assert!( - end <= len, - "range end out of bounds: {:?} <= {:?}", - end, - len, - ); - - if end == begin { - return Bytes::new(); - } - - let mut ret = self.clone(); - - ret.len = end - begin; - ret.ptr = unsafe { ret.ptr.add(begin) }; - - ret - } - - /// Returns a slice of self that is equivalent to the given `subset`. - /// - /// When processing a `Bytes` buffer with other tools, one often gets a - /// `&[u8]` which is in fact a slice of the `Bytes`, i.e. a subset of it. - /// This function turns that `&[u8]` into another `Bytes`, as if one had - /// called `self.slice()` with the offsets that correspond to `subset`. - /// - /// This operation is `O(1)`. - /// - /// # Examples - /// - /// ``` - /// use bytes::Bytes; - /// - /// let bytes = Bytes::from(&b"012345678"[..]); - /// let as_slice = bytes.as_ref(); - /// let subset = &as_slice[2..6]; - /// let subslice = bytes.slice_ref(&subset); - /// assert_eq!(&subslice[..], b"2345"); - /// ``` - /// - /// # Panics - /// - /// Requires that the given `sub` slice is in fact contained within the - /// `Bytes` buffer; otherwise this function will panic. - pub fn slice_ref(&self, subset: &[u8]) -> Self { - // 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() { - return Bytes::new(); - } - - let bytes_p = self.as_ptr() as usize; - let bytes_len = self.len(); - - let sub_p = subset.as_ptr() as usize; - let sub_len = subset.len(); - - assert!( - sub_p >= bytes_p, - "subset pointer ({:p}) is smaller than self pointer ({:p})", - subset.as_ptr(), - self.as_ptr(), - ); - assert!( - sub_p + sub_len <= bytes_p + bytes_len, - "subset is out of bounds: self = ({:p}, {}), subset = ({:p}, {})", - self.as_ptr(), - bytes_len, - subset.as_ptr(), - sub_len, - ); - - let sub_offset = sub_p - bytes_p; - - self.slice(sub_offset..(sub_offset + sub_len)) - } - - /// Splits the bytes into two at the given index. - /// - /// Afterwards `self` contains elements `[0, at)`, and the returned `Bytes` - /// contains elements `[at, len)`. 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. - /// - /// This is an `O(1)` operation that just increases the reference count and - /// sets a few indices. - /// - /// # Examples - /// - /// ``` - /// use bytes::Bytes; - /// - /// let mut a = Bytes::from(&b"hello world"[..]); - /// let b = a.split_off(5); - /// - /// assert_eq!(&a[..], b"hello"); - /// assert_eq!(&b[..], b" world"); - /// ``` - /// - /// # Panics - /// - /// Panics if `at > len`. - #[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)); - } - - assert!( - at <= self.len(), - "split_off out of bounds: {:?} <= {:?}", - at, - self.len(), - ); - - let mut ret = self.clone(); - - self.len = at; - - unsafe { ret.inc_start(at) }; - - ret - } - - /// Splits the bytes into two at the given index. - /// - /// Afterwards `self` contains elements `[at, len)`, and the returned - /// `Bytes` contains elements `[0, at)`. - /// - /// This is an `O(1)` operation that just increases the reference count and - /// sets a few indices. - /// - /// # Examples - /// - /// ``` - /// use bytes::Bytes; - /// - /// let mut a = Bytes::from(&b"hello world"[..]); - /// let b = a.split_to(5); - /// - /// assert_eq!(&a[..], b" world"); - /// assert_eq!(&b[..], b"hello"); - /// ``` - /// - /// # Panics - /// - /// Panics if `at > len`. - #[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); - } - - assert!( - at <= self.len(), - "split_to out of bounds: {:?} <= {:?}", - at, - self.len(), - ); - - let mut ret = self.clone(); - - unsafe { self.inc_start(at) }; - - ret.len = at; - ret - } - - /// Shortens the buffer, keeping the first `len` bytes and dropping the - /// rest. - /// - /// If `len` is greater than the buffer's current length, this has no - /// effect. - /// - /// The [split_off](`Self::split_off()`) method can emulate `truncate`, but this causes the - /// excess bytes to be returned instead of dropped. - /// - /// # Examples - /// - /// ``` - /// use bytes::Bytes; - /// - /// let mut buf = Bytes::from(&b"hello world"[..]); - /// buf.truncate(5); - /// assert_eq!(buf, b"hello"[..]); - /// ``` - #[inline] - pub fn truncate(&mut self, len: usize) { - if len < self.len { - // The Vec "promotable" vtables do not store the capacity, - // so we cannot truncate while using this repr. We *have* to - // promote using `split_off` so the capacity can be stored. - if self.vtable as *const Vtable == &PROMOTABLE_EVEN_VTABLE - || self.vtable as *const Vtable == &PROMOTABLE_ODD_VTABLE - { - drop(self.split_off(len)); - } else { - self.len = len; - } - } - } - - /// Clears the buffer, removing all data. - /// - /// # Examples - /// - /// ``` - /// use bytes::Bytes; - /// - /// let mut buf = Bytes::from(&b"hello world"[..]); - /// buf.clear(); - /// assert!(buf.is_empty()); - /// ``` - #[inline] - pub fn clear(&mut self) { - self.truncate(0); - } - - /// 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. - /// - /// This will also always fail if the buffer was constructed via either - /// [from_owner](Bytes::from_owner) or [from_static](Bytes::from_static). - /// - /// # 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, - len: usize, - data: AtomicPtr<()>, - vtable: &'static Vtable, - ) -> Bytes { - Bytes { - ptr, - len, - data, - vtable, - } - } - - // private - - #[inline] - fn as_slice(&self) -> &[u8] { - unsafe { slice::from_raw_parts(self.ptr, self.len) } - } - - #[inline] - unsafe fn inc_start(&mut self, by: usize) { - // should already be asserted, but debug assert for tests - debug_assert!(self.len >= by, "internal: inc_start out of bounds"); - self.len -= by; - self.ptr = self.ptr.add(by); - } -} - -// Vtable must enforce this behavior -unsafe impl Send for Bytes {} -unsafe impl Sync for Bytes {} - -impl Drop for Bytes { - #[inline] - fn drop(&mut self) { - unsafe { (self.vtable.drop)(&mut self.data, self.ptr, self.len) } - } -} - -impl Clone for Bytes { - #[inline] - fn clone(&self) -> Bytes { - unsafe { (self.vtable.clone)(&self.data, self.ptr, self.len) } - } -} - -impl Buf for Bytes { - #[inline] - fn remaining(&self) -> usize { - self.len() - } - - #[inline] - fn chunk(&self) -> &[u8] { - self.as_slice() - } - - #[inline] - fn advance(&mut self, cnt: usize) { - assert!( - cnt <= self.len(), - "cannot advance past `remaining`: {:?} <= {:?}", - cnt, - self.len(), - ); - - unsafe { - self.inc_start(cnt); - } - } - - fn copy_to_bytes(&mut self, len: usize) -> Self { - self.split_to(len) - } -} - -impl Deref for Bytes { - type Target = [u8]; - - #[inline] - fn deref(&self) -> &[u8] { - self.as_slice() - } -} - -impl AsRef<[u8]> for Bytes { - #[inline] - fn as_ref(&self) -> &[u8] { - self.as_slice() - } -} - -impl hash::Hash for Bytes { - fn hash<H>(&self, state: &mut H) - where - H: hash::Hasher, - { - self.as_slice().hash(state); - } -} - -impl Borrow<[u8]> for Bytes { - fn borrow(&self) -> &[u8] { - self.as_slice() - } -} - -impl IntoIterator for Bytes { - type Item = u8; - type IntoIter = IntoIter<Bytes>; - - fn into_iter(self) -> Self::IntoIter { - IntoIter::new(self) - } -} - -impl<'a> IntoIterator for &'a Bytes { - type Item = &'a u8; - type IntoIter = core::slice::Iter<'a, u8>; - - fn into_iter(self) -> Self::IntoIter { - self.as_slice().iter() - } -} - -impl FromIterator<u8> for Bytes { - fn from_iter<T: IntoIterator<Item = u8>>(into_iter: T) -> Self { - Vec::from_iter(into_iter).into() - } -} - -// impl Eq - -impl PartialEq for Bytes { - fn eq(&self, other: &Bytes) -> bool { - self.as_slice() == other.as_slice() - } -} - -impl PartialOrd for Bytes { - fn partial_cmp(&self, other: &Bytes) -> Option<cmp::Ordering> { - self.as_slice().partial_cmp(other.as_slice()) - } -} - -impl Ord for Bytes { - fn cmp(&self, other: &Bytes) -> cmp::Ordering { - self.as_slice().cmp(other.as_slice()) - } -} - -impl Eq for Bytes {} - -impl PartialEq<[u8]> for Bytes { - fn eq(&self, other: &[u8]) -> bool { - self.as_slice() == other - } -} - -impl PartialOrd<[u8]> for Bytes { - fn partial_cmp(&self, other: &[u8]) -> Option<cmp::Ordering> { - self.as_slice().partial_cmp(other) - } -} - -impl PartialEq<Bytes> for [u8] { - fn eq(&self, other: &Bytes) -> bool { - *other == *self - } -} - -impl PartialOrd<Bytes> for [u8] { - fn partial_cmp(&self, other: &Bytes) -> Option<cmp::Ordering> { - <[u8] as PartialOrd<[u8]>>::partial_cmp(self, other) - } -} - -impl PartialEq<str> for Bytes { - fn eq(&self, other: &str) -> bool { - self.as_slice() == other.as_bytes() - } -} - -impl PartialOrd<str> for Bytes { - fn partial_cmp(&self, other: &str) -> Option<cmp::Ordering> { - self.as_slice().partial_cmp(other.as_bytes()) - } -} - -impl PartialEq<Bytes> for str { - fn eq(&self, other: &Bytes) -> bool { - *other == *self - } -} - -impl PartialOrd<Bytes> for str { - fn partial_cmp(&self, other: &Bytes) -> Option<cmp::Ordering> { - <[u8] as PartialOrd<[u8]>>::partial_cmp(self.as_bytes(), other) - } -} - -impl PartialEq<Vec<u8>> for Bytes { - fn eq(&self, other: &Vec<u8>) -> bool { - *self == other[..] - } -} - -impl PartialOrd<Vec<u8>> for Bytes { - fn partial_cmp(&self, other: &Vec<u8>) -> Option<cmp::Ordering> { - self.as_slice().partial_cmp(&other[..]) - } -} - -impl PartialEq<Bytes> for Vec<u8> { - fn eq(&self, other: &Bytes) -> bool { - *other == *self - } -} - -impl PartialOrd<Bytes> for Vec<u8> { - fn partial_cmp(&self, other: &Bytes) -> Option<cmp::Ordering> { - <[u8] as PartialOrd<[u8]>>::partial_cmp(self, other) - } -} - -impl PartialEq<String> for Bytes { - fn eq(&self, other: &String) -> bool { - *self == other[..] - } -} - -impl PartialOrd<String> for Bytes { - fn partial_cmp(&self, other: &String) -> Option<cmp::Ordering> { - self.as_slice().partial_cmp(other.as_bytes()) - } -} - -impl PartialEq<Bytes> for String { - fn eq(&self, other: &Bytes) -> bool { - *other == *self - } -} - -impl PartialOrd<Bytes> for String { - fn partial_cmp(&self, other: &Bytes) -> Option<cmp::Ordering> { - <[u8] as PartialOrd<[u8]>>::partial_cmp(self.as_bytes(), other) - } -} - -impl PartialEq<Bytes> for &[u8] { - fn eq(&self, other: &Bytes) -> bool { - *other == *self - } -} - -impl PartialOrd<Bytes> for &[u8] { - fn partial_cmp(&self, other: &Bytes) -> Option<cmp::Ordering> { - <[u8] as PartialOrd<[u8]>>::partial_cmp(self, other) - } -} - -impl PartialEq<Bytes> for &str { - fn eq(&self, other: &Bytes) -> bool { - *other == *self - } -} - -impl PartialOrd<Bytes> for &str { - fn partial_cmp(&self, other: &Bytes) -> Option<cmp::Ordering> { - <[u8] as PartialOrd<[u8]>>::partial_cmp(self.as_bytes(), other) - } -} - -impl<'a, T: ?Sized> PartialEq<&'a T> for Bytes -where - Bytes: PartialEq<T>, -{ - fn eq(&self, other: &&'a T) -> bool { - *self == **other - } -} - -impl<'a, T: ?Sized> PartialOrd<&'a T> for Bytes -where - Bytes: PartialOrd<T>, -{ - fn partial_cmp(&self, other: &&'a T) -> Option<cmp::Ordering> { - self.partial_cmp(&**other) - } -} - -// impl From - -impl Default for Bytes { - #[inline] - fn default() -> Bytes { - Bytes::new() - } -} - -impl From<&'static [u8]> for Bytes { - fn from(slice: &'static [u8]) -> Bytes { - Bytes::from_static(slice) - } -} - -impl From<&'static str> for Bytes { - fn from(slice: &'static str) -> Bytes { - Bytes::from_static(slice.as_bytes()) - } -} - -impl From<Vec<u8>> for Bytes { - fn from(vec: Vec<u8>) -> Bytes { - let 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, - // so the pointer isn't aligned enough for the KIND_VEC stashing to - // work. - if slice.is_empty() { - return Bytes::new(); - } - - let len = slice.len(); - let ptr = Box::into_raw(slice) as *mut u8; - - if ptr as usize & 0x1 == 0 { - let data = ptr_map(ptr, |addr| addr | KIND_VEC); - Bytes { - ptr, - len, - data: AtomicPtr::new(data.cast()), - vtable: &PROMOTABLE_EVEN_VTABLE, - } - } else { - Bytes { - ptr, - len, - data: AtomicPtr::new(ptr.cast()), - 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 { - fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result { - f.debug_struct("Vtable") - .field("clone", &(self.clone as *const ())) - .field("drop", &(self.drop as *const ())) - .finish() - } -} - -// ===== impl StaticVtable ===== - -const STATIC_VTABLE: Vtable = Vtable { - clone: static_clone, - to_vec: static_to_vec, - to_mut: static_to_mut, - is_unique: static_is_unique, - drop: static_drop, -}; - -unsafe fn static_clone(_: &AtomicPtr<()>, ptr: *const u8, len: usize) -> Bytes { - let slice = slice::from_raw_parts(ptr, len); - Bytes::from_static(slice) -} - -unsafe fn static_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] -} - -// ===== impl OwnedVtable ===== - -#[repr(C)] -struct OwnedLifetime { - ref_cnt: AtomicUsize, - drop: unsafe fn(*mut ()), -} - -#[repr(C)] -struct Owned<T> { - lifetime: OwnedLifetime, - owner: T, -} - -unsafe fn owned_box_and_drop<T>(ptr: *mut ()) { - let b: Box<Owned<T>> = Box::from_raw(ptr as _); - drop(b); -} - -unsafe fn owned_clone(data: &AtomicPtr<()>, ptr: *const u8, len: usize) -> Bytes { - let owned = data.load(Ordering::Relaxed); - let ref_cnt = &(*owned.cast::<OwnedLifetime>()).ref_cnt; - let old_cnt = ref_cnt.fetch_add(1, Ordering::Relaxed); - if old_cnt > usize::MAX >> 1 { - crate::abort() - } - - Bytes { - ptr, - len, - data: AtomicPtr::new(owned as _), - vtable: &OWNED_VTABLE, - } -} - -unsafe fn owned_to_vec(data: &AtomicPtr<()>, ptr: *const u8, len: usize) -> Vec<u8> { - let slice = slice::from_raw_parts(ptr, len); - let vec = slice.to_vec(); - owned_drop_impl(data.load(Ordering::Relaxed)); - vec -} - -unsafe fn owned_to_mut(data: &AtomicPtr<()>, ptr: *const u8, len: usize) -> BytesMut { - BytesMut::from_vec(owned_to_vec(data, ptr, len)) -} - -unsafe fn owned_is_unique(_data: &AtomicPtr<()>) -> bool { - false -} - -unsafe fn owned_drop_impl(owned: *mut ()) { - let lifetime = owned.cast::<OwnedLifetime>(); - let ref_cnt = &(*lifetime).ref_cnt; - - let old_cnt = ref_cnt.fetch_sub(1, Ordering::Release); - debug_assert!( - old_cnt > 0 && old_cnt <= usize::MAX >> 1, - "expected non-zero refcount and no underflow" - ); - if old_cnt != 1 { - return; - } - ref_cnt.load(Ordering::Acquire); - - let drop_fn = &(*lifetime).drop; - drop_fn(owned) -} - -unsafe fn owned_drop(data: &mut AtomicPtr<()>, _ptr: *const u8, _len: usize) { - let owned = data.load(Ordering::Relaxed); - owned_drop_impl(owned); -} - -static OWNED_VTABLE: Vtable = Vtable { - clone: owned_clone, - to_vec: owned_to_vec, - to_mut: owned_to_mut, - is_unique: owned_is_unique, - drop: owned_drop, -}; - -// ===== impl PromotableVtable ===== - -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, -}; - -unsafe fn promotable_even_clone(data: &AtomicPtr<()>, ptr: *const u8, len: usize) -> Bytes { - let shared = data.load(Ordering::Acquire); - let kind = shared as usize & KIND_MASK; - - if kind == KIND_ARC { - shallow_clone_arc(shared.cast(), ptr, len) - } else { - debug_assert_eq!(kind, KIND_VEC); - let buf = ptr_map(shared.cast(), |addr| addr & !KIND_MASK); - 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()); - } else { - debug_assert_eq!(kind, KIND_VEC); - let buf = ptr_map(shared.cast(), |addr| addr & !KIND_MASK); - free_boxed_slice(buf, ptr, len); - } - }); -} - -unsafe fn promotable_odd_clone(data: &AtomicPtr<()>, ptr: *const u8, len: usize) -> Bytes { - let shared = data.load(Ordering::Acquire); - let kind = shared as usize & KIND_MASK; - - if kind == KIND_ARC { - shallow_clone_arc(shared as _, ptr, len) - } else { - debug_assert_eq!(kind, KIND_VEC); - shallow_clone_vec(data, shared, shared.cast(), 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()); - } else { - debug_assert_eq!(kind, KIND_VEC); - - free_boxed_slice(shared.cast(), 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()) -} - -// ===== impl SharedVtable ===== - -struct Shared { - // Holds arguments to dealloc upon Drop, but otherwise doesn't use them - buf: *mut u8, - cap: usize, - 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. -// This flag is set when the LSB is 0. -const _: [(); 0 - mem::align_of::<Shared>() % 2] = []; // Assert that the alignment of `Shared` is divisible by 2. - -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, -}; - -const KIND_ARC: usize = 0b0; -const KIND_VEC: usize = 0b1; -const KIND_MASK: usize = 0b1; - -unsafe fn shared_clone(data: &AtomicPtr<()>, ptr: *const u8, len: usize) -> Bytes { - let shared = data.load(Ordering::Relaxed); - 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()); - }); -} - -unsafe fn shallow_clone_arc(shared: *mut Shared, ptr: *const u8, len: usize) -> Bytes { - let old_size = (*shared).ref_cnt.fetch_add(1, Ordering::Relaxed); - - if old_size > usize::MAX >> 1 { - crate::abort(); - } - - Bytes { - ptr, - len, - data: AtomicPtr::new(shared as _), - vtable: &SHARED_VTABLE, - } -} - -#[cold] -unsafe fn shallow_clone_vec( - atom: &AtomicPtr<()>, - ptr: *const (), - buf: *mut u8, - offset: *const u8, - len: usize, -) -> Bytes { - // If the buffer is still tracked in a `Vec<u8>`. It is time to - // promote the vec to an `Arc`. This could potentially be called - // concurrently, so some care must be taken. - - // First, allocate a new `Shared` instance containing the - // `Vec` fields. It's important to note that `ptr`, `len`, - // and `cap` cannot be mutated without having `&mut self`. - // This means that these fields will not be concurrently - // updated and since the buffer hasn't been promoted to an - // `Arc`, those three fields still are the components of the - // vector. - let shared = Box::new(Shared { - buf, - cap: offset_from(offset, buf) + len, - // Initialize refcount to 2. One for this reference, and one - // for the new clone that will be returned from - // `shallow_clone`. - ref_cnt: AtomicUsize::new(2), - }); - - let shared = Box::into_raw(shared); - - // The pointer should be aligned, so this assert should - // always succeed. - debug_assert!( - 0 == (shared as usize & KIND_MASK), - "internal: Box<Shared> should have an aligned pointer", - ); - - // Try compare & swapping the pointer into the `arc` field. - // `Release` is used synchronize with other threads that - // will load the `arc` field. - // - // If the `compare_exchange` fails, then the thread lost the - // race to promote the buffer to shared. The `Acquire` - // ordering will synchronize with the `compare_exchange` - // 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); - - // Buffer already promoted to shared storage, so increment ref - // count. - shallow_clone_arc(actual as _, offset, len) - } - } -} - -unsafe fn release_shared(ptr: *mut Shared) { - // `Shared` storage... follow the drop steps from Arc. - if (*ptr).ref_cnt.fetch_sub(1, Ordering::Release) != 1 { - return; - } - - // This fence is needed to prevent reordering of use of the data and - // deletion of the data. Because it is marked `Release`, the decreasing - // of the reference count synchronizes with this `Acquire` fence. This - // means that use of the data happens before decreasing the reference - // count, which happens before this fence, which happens before the - // deletion of the data. - // - // As explained in the [Boost documentation][1], - // - // > It is important to enforce any possible access to the object in one - // > thread (through an existing reference) to *happen before* deleting - // > the object in a different thread. This is achieved by a "release" - // > operation after dropping a reference (any access to the object - // > through this reference must obviously happened before), and an - // > "acquire" operation before deleting the object. - // - // [1]: (www.boost.org/doc/libs/1_55_0/doc/html/atomic/usage_examples.html) - // - // Thread sanitizer does not support atomic fences. Use an atomic load - // instead. - (*ptr).ref_cnt.load(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) -} - -// compile-fails - -/// ```compile_fail -/// use bytes::Bytes; -/// #[deny(unused_must_use)] -/// { -/// let mut b1 = Bytes::from("hello world"); -/// b1.split_to(6); -/// } -/// ``` -fn _split_to_must_use() {} - -/// ```compile_fail -/// use bytes::Bytes; -/// #[deny(unused_must_use)] -/// { -/// let mut b1 = Bytes::from("hello world"); -/// b1.split_off(6); -/// } -/// ``` -fn _split_off_must_use() {} - -// fuzz tests -#[cfg(all(test, loom))] -mod fuzz { - use loom::sync::Arc; - use loom::thread; - - use super::Bytes; - #[test] - fn bytes_cloning_vec() { - loom::model(|| { - let a = Bytes::from(b"abcdefgh".to_vec()); - let addr = a.as_ptr() as usize; - - // test the Bytes::clone is Sync by putting it in an Arc - let a1 = Arc::new(a); - let a2 = a1.clone(); - - let t1 = thread::spawn(move || { - let b: Bytes = (*a1).clone(); - assert_eq!(b.as_ptr() as usize, addr); - }); - - let t2 = thread::spawn(move || { - let b: Bytes = (*a2).clone(); - assert_eq!(b.as_ptr() as usize, addr); - }); - - t1.join().unwrap(); - t2.join().unwrap(); - }); - } -} diff --git a/vendor/bytes/src/bytes_mut.rs b/vendor/bytes/src/bytes_mut.rs deleted file mode 100644 index d5db5124..00000000 --- a/vendor/bytes/src/bytes_mut.rs +++ /dev/null @@ -1,1921 +0,0 @@ -use core::iter::FromIterator; -use core::mem::{self, ManuallyDrop, MaybeUninit}; -use core::ops::{Deref, DerefMut}; -use core::ptr::{self, NonNull}; -use core::{cmp, fmt, hash, isize, slice, usize}; - -use alloc::{ - borrow::{Borrow, BorrowMut}, - boxed::Box, - string::String, - vec, - vec::Vec, -}; - -use crate::buf::{IntoIter, UninitSlice}; -use crate::bytes::Vtable; -#[allow(unused)] -use crate::loom::sync::atomic::AtomicMut; -use crate::loom::sync::atomic::{AtomicPtr, AtomicUsize, Ordering}; -use crate::{offset_from, Buf, BufMut, Bytes, TryGetError}; - -/// A unique reference to a contiguous slice of memory. -/// -/// `BytesMut` represents a unique view into a potentially shared memory region. -/// Given the uniqueness guarantee, owners of `BytesMut` handles are able to -/// mutate the memory. -/// -/// `BytesMut` can be thought of as containing a `buf: Arc<Vec<u8>>`, an offset -/// into `buf`, a slice length, and a guarantee that no other `BytesMut` for the -/// same `buf` overlaps with its slice. That guarantee means that a write lock -/// is not required. -/// -/// # Growth -/// -/// `BytesMut`'s `BufMut` implementation will implicitly grow its buffer as -/// necessary. However, explicitly reserving the required space up-front before -/// a series of inserts will be more efficient. -/// -/// # Examples -/// -/// ``` -/// use bytes::{BytesMut, BufMut}; -/// -/// let mut buf = BytesMut::with_capacity(64); -/// -/// buf.put_u8(b'h'); -/// buf.put_u8(b'e'); -/// buf.put(&b"llo"[..]); -/// -/// assert_eq!(&buf[..], b"hello"); -/// -/// // Freeze the buffer so that it can be shared -/// let a = buf.freeze(); -/// -/// // This does not allocate, instead `b` points to the same memory. -/// let b = a.clone(); -/// -/// assert_eq!(&a[..], b"hello"); -/// assert_eq!(&b[..], b"hello"); -/// ``` -pub struct BytesMut { - ptr: NonNull<u8>, - len: usize, - cap: usize, - data: *mut Shared, -} - -// Thread-safe reference-counted container for the shared storage. This mostly -// the same as `core::sync::Arc` but without the weak counter. The ref counting -// fns are based on the ones found in `std`. -// -// The main reason to use `Shared` instead of `core::sync::Arc` is that it ends -// up making the overall code simpler and easier to reason about. This is due to -// some of the logic around setting `Inner::arc` and other ways the `arc` field -// is used. Using `Arc` ended up requiring a number of funky transmutes and -// other shenanigans to make it work. -struct Shared { - vec: Vec<u8>, - original_capacity_repr: usize, - ref_count: AtomicUsize, -} - -// 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. -// This flag is set when the LSB is 0. -const _: [(); 0 - mem::align_of::<Shared>() % 2] = []; // Assert that the alignment of `Shared` is divisible by 2. - -// Buffer storage strategy flags. -const KIND_ARC: usize = 0b0; -const KIND_VEC: usize = 0b1; -const KIND_MASK: usize = 0b1; - -// The max original capacity value. Any `Bytes` allocated with a greater initial -// capacity will default to this. -const MAX_ORIGINAL_CAPACITY_WIDTH: usize = 17; -// The original capacity algorithm will not take effect unless the originally -// allocated capacity was at least 1kb in size. -const MIN_ORIGINAL_CAPACITY_WIDTH: usize = 10; -// The original capacity is stored in powers of 2 starting at 1kb to a max of -// 64kb. Representing it as such requires only 3 bits of storage. -const ORIGINAL_CAPACITY_MASK: usize = 0b11100; -const ORIGINAL_CAPACITY_OFFSET: usize = 2; - -const VEC_POS_OFFSET: usize = 5; -// When the storage is in the `Vec` representation, the pointer can be advanced -// at most this value. This is due to the amount of storage available to track -// the offset is usize - number of KIND bits and number of ORIGINAL_CAPACITY -// bits. -const MAX_VEC_POS: usize = usize::MAX >> VEC_POS_OFFSET; -const NOT_VEC_POS_MASK: usize = 0b11111; - -#[cfg(target_pointer_width = "64")] -const PTR_WIDTH: usize = 64; -#[cfg(target_pointer_width = "32")] -const PTR_WIDTH: usize = 32; - -/* - * - * ===== BytesMut ===== - * - */ - -impl BytesMut { - /// Creates a new `BytesMut` with the specified capacity. - /// - /// The returned `BytesMut` will be able to hold at least `capacity` bytes - /// without reallocating. - /// - /// It is important to note that this function does not specify the length - /// of the returned `BytesMut`, but only the capacity. - /// - /// # Examples - /// - /// ``` - /// use bytes::{BytesMut, BufMut}; - /// - /// let mut bytes = BytesMut::with_capacity(64); - /// - /// // `bytes` contains no data, even though there is capacity - /// assert_eq!(bytes.len(), 0); - /// - /// bytes.put(&b"hello world"[..]); - /// - /// assert_eq!(&bytes[..], b"hello world"); - /// ``` - #[inline] - pub fn with_capacity(capacity: usize) -> BytesMut { - BytesMut::from_vec(Vec::with_capacity(capacity)) - } - - /// Creates a new `BytesMut` with default capacity. - /// - /// Resulting object has length 0 and unspecified capacity. - /// This function does not allocate. - /// - /// # Examples - /// - /// ``` - /// use bytes::{BytesMut, BufMut}; - /// - /// let mut bytes = BytesMut::new(); - /// - /// assert_eq!(0, bytes.len()); - /// - /// bytes.reserve(2); - /// bytes.put_slice(b"xy"); - /// - /// assert_eq!(&b"xy"[..], &bytes[..]); - /// ``` - #[inline] - pub fn new() -> BytesMut { - BytesMut::with_capacity(0) - } - - /// Returns the number of bytes contained in this `BytesMut`. - /// - /// # Examples - /// - /// ``` - /// use bytes::BytesMut; - /// - /// let b = BytesMut::from(&b"hello"[..]); - /// assert_eq!(b.len(), 5); - /// ``` - #[inline] - pub fn len(&self) -> usize { - self.len - } - - /// Returns true if the `BytesMut` has a length of 0. - /// - /// # Examples - /// - /// ``` - /// use bytes::BytesMut; - /// - /// let b = BytesMut::with_capacity(64); - /// assert!(b.is_empty()); - /// ``` - #[inline] - pub fn is_empty(&self) -> bool { - self.len == 0 - } - - /// Returns the number of bytes the `BytesMut` can hold without reallocating. - /// - /// # Examples - /// - /// ``` - /// use bytes::BytesMut; - /// - /// let b = BytesMut::with_capacity(64); - /// assert_eq!(b.capacity(), 64); - /// ``` - #[inline] - pub fn capacity(&self) -> usize { - self.cap - } - - /// Converts `self` into an immutable `Bytes`. - /// - /// The conversion is zero cost and is used to indicate that the slice - /// referenced by the handle will no longer be mutated. Once the conversion - /// is done, the handle can be cloned and shared across threads. - /// - /// # Examples - /// - /// ``` - /// use bytes::{BytesMut, BufMut}; - /// use std::thread; - /// - /// let mut b = BytesMut::with_capacity(64); - /// b.put(&b"hello world"[..]); - /// let b1 = b.freeze(); - /// let b2 = b1.clone(); - /// - /// let th = thread::spawn(move || { - /// assert_eq!(&b1[..], b"hello world"); - /// }); - /// - /// assert_eq!(&b2[..], b"hello world"); - /// th.join().unwrap(); - /// ``` - #[inline] - pub fn freeze(self) -> Bytes { - let bytes = ManuallyDrop::new(self); - if bytes.kind() == KIND_VEC { - // Just re-use `Bytes` internal Vec vtable - unsafe { - let off = bytes.get_vec_pos(); - let vec = rebuild_vec(bytes.ptr.as_ptr(), bytes.len, bytes.cap, off); - let mut b: Bytes = vec.into(); - b.advance(off); - b - } - } else { - debug_assert_eq!(bytes.kind(), KIND_ARC); - - let ptr = bytes.ptr.as_ptr(); - let len = bytes.len; - let data = AtomicPtr::new(bytes.data.cast()); - unsafe { Bytes::with_vtable(ptr, len, data, &SHARED_VTABLE) } - } - } - - /// Creates a new `BytesMut` containing `len` zeros. - /// - /// The resulting object has a length of `len` and a capacity greater - /// than or equal to `len`. The entire length of the object will be filled - /// with zeros. - /// - /// On some platforms or allocators this function may be faster than - /// a manual implementation. - /// - /// # Examples - /// - /// ``` - /// use bytes::BytesMut; - /// - /// let zeros = BytesMut::zeroed(42); - /// - /// assert!(zeros.capacity() >= 42); - /// assert_eq!(zeros.len(), 42); - /// zeros.into_iter().for_each(|x| assert_eq!(x, 0)); - /// ``` - pub fn zeroed(len: usize) -> BytesMut { - BytesMut::from_vec(vec![0; len]) - } - - /// Splits the bytes into two at the given index. - /// - /// Afterwards `self` contains elements `[0, at)`, and the returned - /// `BytesMut` contains elements `[at, capacity)`. 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. - /// - /// This is an `O(1)` operation that just increases the reference count - /// and sets a few indices. - /// - /// # Examples - /// - /// ``` - /// use bytes::BytesMut; - /// - /// let mut a = BytesMut::from(&b"hello world"[..]); - /// let mut b = a.split_off(5); - /// - /// a[0] = b'j'; - /// b[0] = b'!'; - /// - /// assert_eq!(&a[..], b"jello"); - /// assert_eq!(&b[..], b"!world"); - /// ``` - /// - /// # Panics - /// - /// Panics if `at > capacity`. - #[must_use = "consider BytesMut::truncate if you don't need the other half"] - pub fn split_off(&mut self, at: usize) -> BytesMut { - assert!( - at <= self.capacity(), - "split_off out of bounds: {:?} <= {:?}", - at, - self.capacity(), - ); - unsafe { - let mut other = self.shallow_clone(); - // SAFETY: We've checked that `at` <= `self.capacity()` above. - other.advance_unchecked(at); - self.cap = at; - self.len = cmp::min(self.len, at); - other - } - } - - /// Removes the bytes from the current view, returning them in a new - /// `BytesMut` handle. - /// - /// Afterwards, `self` will be empty, but will retain any additional - /// capacity that it had before the operation. This is identical to - /// `self.split_to(self.len())`. - /// - /// This is an `O(1)` operation that just increases the reference count and - /// sets a few indices. - /// - /// # Examples - /// - /// ``` - /// use bytes::{BytesMut, BufMut}; - /// - /// let mut buf = BytesMut::with_capacity(1024); - /// buf.put(&b"hello world"[..]); - /// - /// let other = buf.split(); - /// - /// assert!(buf.is_empty()); - /// assert_eq!(1013, buf.capacity()); - /// - /// assert_eq!(other, b"hello world"[..]); - /// ``` - #[must_use = "consider BytesMut::clear if you don't need the other half"] - pub fn split(&mut self) -> BytesMut { - let len = self.len(); - self.split_to(len) - } - - /// Splits the buffer into two at the given index. - /// - /// Afterwards `self` contains elements `[at, len)`, and the returned `BytesMut` - /// contains elements `[0, at)`. - /// - /// This is an `O(1)` operation that just increases the reference count and - /// sets a few indices. - /// - /// # Examples - /// - /// ``` - /// use bytes::BytesMut; - /// - /// let mut a = BytesMut::from(&b"hello world"[..]); - /// let mut b = a.split_to(5); - /// - /// a[0] = b'!'; - /// b[0] = b'j'; - /// - /// assert_eq!(&a[..], b"!world"); - /// assert_eq!(&b[..], b"jello"); - /// ``` - /// - /// # Panics - /// - /// Panics if `at > len`. - #[must_use = "consider BytesMut::advance if you don't need the other half"] - pub fn split_to(&mut self, at: usize) -> BytesMut { - assert!( - at <= self.len(), - "split_to out of bounds: {:?} <= {:?}", - at, - self.len(), - ); - - unsafe { - let mut other = self.shallow_clone(); - // SAFETY: We've checked that `at` <= `self.len()` and we know that `self.len()` <= - // `self.capacity()`. - self.advance_unchecked(at); - other.cap = at; - other.len = at; - other - } - } - - /// Shortens the buffer, keeping the first `len` bytes and dropping the - /// rest. - /// - /// If `len` is greater than the buffer's current length, this has no - /// effect. - /// - /// Existing underlying capacity is preserved. - /// - /// The [split_off](`Self::split_off()`) method can emulate `truncate`, but this causes the - /// excess bytes to be returned instead of dropped. - /// - /// # Examples - /// - /// ``` - /// use bytes::BytesMut; - /// - /// let mut buf = BytesMut::from(&b"hello world"[..]); - /// buf.truncate(5); - /// assert_eq!(buf, b"hello"[..]); - /// ``` - pub fn truncate(&mut self, len: usize) { - if len <= self.len() { - // SAFETY: Shrinking the buffer cannot expose uninitialized bytes. - unsafe { self.set_len(len) }; - } - } - - /// Clears the buffer, removing all data. Existing capacity is preserved. - /// - /// # Examples - /// - /// ``` - /// use bytes::BytesMut; - /// - /// let mut buf = BytesMut::from(&b"hello world"[..]); - /// buf.clear(); - /// assert!(buf.is_empty()); - /// ``` - pub fn clear(&mut self) { - // SAFETY: Setting the length to zero cannot expose uninitialized bytes. - unsafe { self.set_len(0) }; - } - - /// Resizes the buffer so that `len` is equal to `new_len`. - /// - /// If `new_len` is greater than `len`, the buffer is extended by the - /// difference with each additional byte set to `value`. If `new_len` is - /// less than `len`, the buffer is simply truncated. - /// - /// # Examples - /// - /// ``` - /// use bytes::BytesMut; - /// - /// let mut buf = BytesMut::new(); - /// - /// buf.resize(3, 0x1); - /// assert_eq!(&buf[..], &[0x1, 0x1, 0x1]); - /// - /// buf.resize(2, 0x2); - /// assert_eq!(&buf[..], &[0x1, 0x1]); - /// - /// buf.resize(4, 0x3); - /// assert_eq!(&buf[..], &[0x1, 0x1, 0x3, 0x3]); - /// ``` - pub fn resize(&mut self, new_len: usize, value: u8) { - let additional = if let Some(additional) = new_len.checked_sub(self.len()) { - additional - } else { - self.truncate(new_len); - return; - }; - - if additional == 0 { - return; - } - - self.reserve(additional); - let dst = self.spare_capacity_mut().as_mut_ptr(); - // SAFETY: `spare_capacity_mut` returns a valid, properly aligned pointer and we've - // reserved enough space to write `additional` bytes. - unsafe { ptr::write_bytes(dst, value, additional) }; - - // SAFETY: There are at least `new_len` initialized bytes in the buffer so no - // uninitialized bytes are being exposed. - unsafe { self.set_len(new_len) }; - } - - /// Sets the length of the buffer. - /// - /// This will explicitly set the size of the buffer without actually - /// modifying the data, so it is up to the caller to ensure that the data - /// has been initialized. - /// - /// # Examples - /// - /// ``` - /// use bytes::BytesMut; - /// - /// let mut b = BytesMut::from(&b"hello world"[..]); - /// - /// unsafe { - /// b.set_len(5); - /// } - /// - /// assert_eq!(&b[..], b"hello"); - /// - /// unsafe { - /// b.set_len(11); - /// } - /// - /// assert_eq!(&b[..], b"hello world"); - /// ``` - #[inline] - pub unsafe fn set_len(&mut self, len: usize) { - debug_assert!(len <= self.cap, "set_len out of bounds"); - self.len = len; - } - - /// Reserves capacity for at least `additional` more bytes to be inserted - /// into the given `BytesMut`. - /// - /// More than `additional` bytes may be reserved in order to avoid frequent - /// reallocations. A call to `reserve` may result in an allocation. - /// - /// Before allocating new buffer space, the function will attempt to reclaim - /// space in the existing buffer. If the current handle references a view - /// into a larger original buffer, and all other handles referencing part - /// of the same original buffer have been dropped, then the current view - /// can be copied/shifted to the front of the buffer and the handle can take - /// ownership of the full buffer, provided that the full buffer is large - /// enough to fit the requested additional capacity. - /// - /// This optimization will only happen if shifting the data from the current - /// view to the front of the buffer is not too expensive in terms of the - /// (amortized) time required. The precise condition is subject to change; - /// as of now, the length of the data being shifted needs to be at least as - /// large as the distance that it's shifted by. If the current view is empty - /// and the original buffer is large enough to fit the requested additional - /// capacity, then reallocations will never happen. - /// - /// # Examples - /// - /// In the following example, a new buffer is allocated. - /// - /// ``` - /// use bytes::BytesMut; - /// - /// let mut buf = BytesMut::from(&b"hello"[..]); - /// buf.reserve(64); - /// assert!(buf.capacity() >= 69); - /// ``` - /// - /// In the following example, the existing buffer is reclaimed. - /// - /// ``` - /// use bytes::{BytesMut, BufMut}; - /// - /// let mut buf = BytesMut::with_capacity(128); - /// buf.put(&[0; 64][..]); - /// - /// let ptr = buf.as_ptr(); - /// let other = buf.split(); - /// - /// assert!(buf.is_empty()); - /// assert_eq!(buf.capacity(), 64); - /// - /// drop(other); - /// buf.reserve(128); - /// - /// assert_eq!(buf.capacity(), 128); - /// assert_eq!(buf.as_ptr(), ptr); - /// ``` - /// - /// # Panics - /// - /// Panics if the new capacity overflows `usize`. - #[inline] - pub fn reserve(&mut self, additional: usize) { - let len = self.len(); - let rem = self.capacity() - len; - - if additional <= rem { - // The handle can already store at least `additional` more bytes, so - // there is no further work needed to be done. - return; - } - - // will always succeed - let _ = self.reserve_inner(additional, true); - } - - // In separate function to allow the short-circuits in `reserve` and `try_reclaim` to - // be inline-able. Significantly helps performance. Returns false if it did not succeed. - fn reserve_inner(&mut self, additional: usize, allocate: bool) -> bool { - let len = self.len(); - let kind = self.kind(); - - if kind == KIND_VEC { - // If there's enough free space before the start of the buffer, then - // just copy the data backwards and reuse the already-allocated - // space. - // - // Otherwise, since backed by a vector, use `Vec::reserve` - // - // We need to make sure that this optimization does not kill the - // amortized runtimes of BytesMut's operations. - unsafe { - let off = self.get_vec_pos(); - - // Only reuse space if we can satisfy the requested additional space. - // - // Also check if the value of `off` suggests that enough bytes - // have been read to account for the overhead of shifting all - // the data (in an amortized analysis). - // Hence the condition `off >= self.len()`. - // - // This condition also already implies that the buffer is going - // to be (at least) half-empty in the end; so we do not break - // the (amortized) runtime with future resizes of the underlying - // `Vec`. - // - // [For more details check issue #524, and PR #525.] - if self.capacity() - self.len() + off >= additional && off >= self.len() { - // There's enough space, and it's not too much overhead: - // reuse the space! - // - // Just move the pointer back to the start after copying - // data back. - let base_ptr = self.ptr.as_ptr().sub(off); - // Since `off >= self.len()`, the two regions don't overlap. - ptr::copy_nonoverlapping(self.ptr.as_ptr(), base_ptr, self.len); - self.ptr = vptr(base_ptr); - self.set_vec_pos(0); - - // Length stays constant, but since we moved backwards we - // can gain capacity back. - self.cap += off; - } else { - if !allocate { - return false; - } - // Not enough space, or reusing might be too much overhead: - // allocate more space! - let mut v = - ManuallyDrop::new(rebuild_vec(self.ptr.as_ptr(), self.len, self.cap, off)); - v.reserve(additional); - - // Update the info - self.ptr = vptr(v.as_mut_ptr().add(off)); - self.cap = v.capacity() - off; - debug_assert_eq!(self.len, v.len() - off); - } - - return true; - } - } - - debug_assert_eq!(kind, KIND_ARC); - let shared: *mut Shared = self.data; - - // Reserving involves abandoning the currently shared buffer and - // allocating a new vector with the requested capacity. - // - // Compute the new capacity - let mut new_cap = match len.checked_add(additional) { - Some(new_cap) => new_cap, - None if !allocate => return false, - None => panic!("overflow"), - }; - - unsafe { - // First, try to reclaim the buffer. This is possible if the current - // handle is the only outstanding handle pointing to the buffer. - if (*shared).is_unique() { - // This is the only handle to the buffer. It can be reclaimed. - // However, before doing the work of copying data, check to make - // sure that the vector has enough capacity. - let v = &mut (*shared).vec; - - let v_capacity = v.capacity(); - let ptr = v.as_mut_ptr(); - - let offset = offset_from(self.ptr.as_ptr(), ptr); - - // Compare the condition in the `kind == KIND_VEC` case above - // for more details. - if v_capacity >= new_cap + offset { - self.cap = new_cap; - // no copy is necessary - } else if v_capacity >= new_cap && offset >= len { - // The capacity is sufficient, and copying is not too much - // overhead: reclaim the buffer! - - // `offset >= len` means: no overlap - ptr::copy_nonoverlapping(self.ptr.as_ptr(), ptr, len); - - self.ptr = vptr(ptr); - self.cap = v.capacity(); - } else { - if !allocate { - return false; - } - // calculate offset - let off = (self.ptr.as_ptr() as usize) - (v.as_ptr() as usize); - - // new_cap is calculated in terms of `BytesMut`, not the underlying - // `Vec`, so it does not take the offset into account. - // - // Thus we have to manually add it here. - new_cap = new_cap.checked_add(off).expect("overflow"); - - // The vector capacity is not sufficient. The reserve request is - // asking for more than the initial buffer capacity. Allocate more - // than requested if `new_cap` is not much bigger than the current - // capacity. - // - // There are some situations, using `reserve_exact` that the - // buffer capacity could be below `original_capacity`, so do a - // check. - let double = v.capacity().checked_shl(1).unwrap_or(new_cap); - - new_cap = cmp::max(double, new_cap); - - // No space - allocate more - // - // The length field of `Shared::vec` is not used by the `BytesMut`; - // instead we use the `len` field in the `BytesMut` itself. However, - // when calling `reserve`, it doesn't guarantee that data stored in - // the unused capacity of the vector is copied over to the new - // allocation, so we need to ensure that we don't have any data we - // care about in the unused capacity before calling `reserve`. - debug_assert!(off + len <= v.capacity()); - v.set_len(off + len); - v.reserve(new_cap - v.len()); - - // Update the info - self.ptr = vptr(v.as_mut_ptr().add(off)); - self.cap = v.capacity() - off; - } - - return true; - } - } - if !allocate { - return false; - } - - let original_capacity_repr = unsafe { (*shared).original_capacity_repr }; - let original_capacity = original_capacity_from_repr(original_capacity_repr); - - new_cap = cmp::max(new_cap, original_capacity); - - // Create a new vector to store the data - let mut v = ManuallyDrop::new(Vec::with_capacity(new_cap)); - - // Copy the bytes - v.extend_from_slice(self.as_ref()); - - // Release the shared handle. This must be done *after* the bytes are - // copied. - unsafe { release_shared(shared) }; - - // Update self - let data = (original_capacity_repr << ORIGINAL_CAPACITY_OFFSET) | KIND_VEC; - self.data = invalid_ptr(data); - self.ptr = vptr(v.as_mut_ptr()); - self.cap = v.capacity(); - debug_assert_eq!(self.len, v.len()); - return true; - } - - /// Attempts to cheaply reclaim already allocated capacity for at least `additional` more - /// bytes to be inserted into the given `BytesMut` and returns `true` if it succeeded. - /// - /// `try_reclaim` behaves exactly like `reserve`, except that it never allocates new storage - /// and returns a `bool` indicating whether it was successful in doing so: - /// - /// `try_reclaim` returns false under these conditions: - /// - The spare capacity left is less than `additional` bytes AND - /// - The existing allocation cannot be reclaimed cheaply or it was less than - /// `additional` bytes in size - /// - /// Reclaiming the allocation cheaply is possible if the `BytesMut` has no outstanding - /// references through other `BytesMut`s or `Bytes` which point to the same underlying - /// storage. - /// - /// # Examples - /// - /// ``` - /// use bytes::BytesMut; - /// - /// let mut buf = BytesMut::with_capacity(64); - /// assert_eq!(true, buf.try_reclaim(64)); - /// assert_eq!(64, buf.capacity()); - /// - /// buf.extend_from_slice(b"abcd"); - /// let mut split = buf.split(); - /// assert_eq!(60, buf.capacity()); - /// assert_eq!(4, split.capacity()); - /// assert_eq!(false, split.try_reclaim(64)); - /// assert_eq!(false, buf.try_reclaim(64)); - /// // The split buffer is filled with "abcd" - /// assert_eq!(false, split.try_reclaim(4)); - /// // buf is empty and has capacity for 60 bytes - /// assert_eq!(true, buf.try_reclaim(60)); - /// - /// drop(buf); - /// assert_eq!(false, split.try_reclaim(64)); - /// - /// split.clear(); - /// assert_eq!(4, split.capacity()); - /// assert_eq!(true, split.try_reclaim(64)); - /// assert_eq!(64, split.capacity()); - /// ``` - // I tried splitting out try_reclaim_inner after the short circuits, but it was inlined - // regardless with Rust 1.78.0 so probably not worth it - #[inline] - #[must_use = "consider BytesMut::reserve if you need an infallible reservation"] - pub fn try_reclaim(&mut self, additional: usize) -> bool { - let len = self.len(); - let rem = self.capacity() - len; - - if additional <= rem { - // The handle can already store at least `additional` more bytes, so - // there is no further work needed to be done. - return true; - } - - self.reserve_inner(additional, false) - } - - /// Appends given bytes to this `BytesMut`. - /// - /// If this `BytesMut` object does not have enough capacity, it is resized - /// first. - /// - /// # Examples - /// - /// ``` - /// use bytes::BytesMut; - /// - /// let mut buf = BytesMut::with_capacity(0); - /// buf.extend_from_slice(b"aaabbb"); - /// buf.extend_from_slice(b"cccddd"); - /// - /// assert_eq!(b"aaabbbcccddd", &buf[..]); - /// ``` - #[inline] - pub fn extend_from_slice(&mut self, extend: &[u8]) { - let cnt = extend.len(); - self.reserve(cnt); - - unsafe { - let dst = self.spare_capacity_mut(); - // Reserved above - debug_assert!(dst.len() >= cnt); - - ptr::copy_nonoverlapping(extend.as_ptr(), dst.as_mut_ptr().cast(), cnt); - } - - unsafe { - self.advance_mut(cnt); - } - } - - /// Absorbs a `BytesMut` that was previously split off. - /// - /// If the two `BytesMut` objects were previously contiguous and not mutated - /// in a way that causes re-allocation i.e., if `other` was created by - /// calling `split_off` on this `BytesMut`, then this is an `O(1)` operation - /// that just decreases a reference count and sets a few indices. - /// Otherwise this method degenerates to - /// `self.extend_from_slice(other.as_ref())`. - /// - /// # Examples - /// - /// ``` - /// use bytes::BytesMut; - /// - /// let mut buf = BytesMut::with_capacity(64); - /// buf.extend_from_slice(b"aaabbbcccddd"); - /// - /// let split = buf.split_off(6); - /// assert_eq!(b"aaabbb", &buf[..]); - /// assert_eq!(b"cccddd", &split[..]); - /// - /// buf.unsplit(split); - /// assert_eq!(b"aaabbbcccddd", &buf[..]); - /// ``` - pub fn unsplit(&mut self, other: BytesMut) { - if self.is_empty() { - *self = other; - return; - } - - if let Err(other) = self.try_unsplit(other) { - self.extend_from_slice(other.as_ref()); - } - } - - // private - - // For now, use a `Vec` to manage the memory for us, but we may want to - // change that in the future to some alternate allocator strategy. - // - // Thus, we don't expose an easy way to construct from a `Vec` since an - // internal change could make a simple pattern (`BytesMut::from(vec)`) - // suddenly a lot more expensive. - #[inline] - pub(crate) fn from_vec(vec: Vec<u8>) -> BytesMut { - let mut vec = ManuallyDrop::new(vec); - let ptr = vptr(vec.as_mut_ptr()); - let len = vec.len(); - let cap = vec.capacity(); - - let original_capacity_repr = original_capacity_to_repr(cap); - let data = (original_capacity_repr << ORIGINAL_CAPACITY_OFFSET) | KIND_VEC; - - BytesMut { - ptr, - len, - cap, - data: invalid_ptr(data), - } - } - - #[inline] - fn as_slice(&self) -> &[u8] { - unsafe { slice::from_raw_parts(self.ptr.as_ptr(), self.len) } - } - - #[inline] - fn as_slice_mut(&mut self) -> &mut [u8] { - unsafe { slice::from_raw_parts_mut(self.ptr.as_ptr(), self.len) } - } - - /// Advance the buffer without bounds checking. - /// - /// # SAFETY - /// - /// The caller must ensure that `count` <= `self.cap`. - pub(crate) unsafe fn advance_unchecked(&mut self, count: usize) { - // Setting the start to 0 is a no-op, so return early if this is the - // case. - if count == 0 { - return; - } - - debug_assert!(count <= self.cap, "internal: set_start out of bounds"); - - let kind = self.kind(); - - if kind == KIND_VEC { - // Setting the start when in vec representation is a little more - // complicated. First, we have to track how far ahead the - // "start" of the byte buffer from the beginning of the vec. We - // also have to ensure that we don't exceed the maximum shift. - let pos = self.get_vec_pos() + count; - - if pos <= MAX_VEC_POS { - self.set_vec_pos(pos); - } else { - // The repr must be upgraded to ARC. This will never happen - // on 64 bit systems and will only happen on 32 bit systems - // when shifting past 134,217,727 bytes. As such, we don't - // worry too much about performance here. - self.promote_to_shared(/*ref_count = */ 1); - } - } - - // Updating the start of the view is setting `ptr` to point to the - // new start and updating the `len` field to reflect the new length - // of the view. - self.ptr = vptr(self.ptr.as_ptr().add(count)); - self.len = self.len.checked_sub(count).unwrap_or(0); - self.cap -= count; - } - - fn try_unsplit(&mut self, other: BytesMut) -> Result<(), BytesMut> { - if other.capacity() == 0 { - return Ok(()); - } - - let ptr = unsafe { self.ptr.as_ptr().add(self.len) }; - if ptr == other.ptr.as_ptr() - && self.kind() == KIND_ARC - && other.kind() == KIND_ARC - && self.data == other.data - { - // Contiguous blocks, just combine directly - self.len += other.len; - self.cap += other.cap; - Ok(()) - } else { - Err(other) - } - } - - #[inline] - fn kind(&self) -> usize { - self.data as usize & KIND_MASK - } - - unsafe fn promote_to_shared(&mut self, ref_cnt: usize) { - debug_assert_eq!(self.kind(), KIND_VEC); - debug_assert!(ref_cnt == 1 || ref_cnt == 2); - - let original_capacity_repr = - (self.data as usize & ORIGINAL_CAPACITY_MASK) >> ORIGINAL_CAPACITY_OFFSET; - - // The vec offset cannot be concurrently mutated, so there - // should be no danger reading it. - let off = (self.data as usize) >> VEC_POS_OFFSET; - - // First, allocate a new `Shared` instance containing the - // `Vec` fields. It's important to note that `ptr`, `len`, - // and `cap` cannot be mutated without having `&mut self`. - // This means that these fields will not be concurrently - // updated and since the buffer hasn't been promoted to an - // `Arc`, those three fields still are the components of the - // vector. - let shared = Box::new(Shared { - vec: rebuild_vec(self.ptr.as_ptr(), self.len, self.cap, off), - original_capacity_repr, - ref_count: AtomicUsize::new(ref_cnt), - }); - - let shared = Box::into_raw(shared); - - // The pointer should be aligned, so this assert should - // always succeed. - debug_assert_eq!(shared as usize & KIND_MASK, KIND_ARC); - - self.data = shared; - } - - /// Makes an exact shallow clone of `self`. - /// - /// The kind of `self` doesn't matter, but this is unsafe - /// because the clone will have the same offsets. You must - /// be sure the returned value to the user doesn't allow - /// two views into the same range. - #[inline] - unsafe fn shallow_clone(&mut self) -> BytesMut { - if self.kind() == KIND_ARC { - increment_shared(self.data); - ptr::read(self) - } else { - self.promote_to_shared(/*ref_count = */ 2); - ptr::read(self) - } - } - - #[inline] - unsafe fn get_vec_pos(&self) -> usize { - debug_assert_eq!(self.kind(), KIND_VEC); - - self.data as usize >> VEC_POS_OFFSET - } - - #[inline] - unsafe fn set_vec_pos(&mut self, pos: usize) { - debug_assert_eq!(self.kind(), KIND_VEC); - debug_assert!(pos <= MAX_VEC_POS); - - self.data = invalid_ptr((pos << VEC_POS_OFFSET) | (self.data as usize & NOT_VEC_POS_MASK)); - } - - /// Returns the remaining spare capacity of the buffer as a slice of `MaybeUninit<u8>`. - /// - /// The returned slice can be used to fill the buffer with data (e.g. by - /// reading from a file) before marking the data as initialized using the - /// [`set_len`] method. - /// - /// [`set_len`]: BytesMut::set_len - /// - /// # Examples - /// - /// ``` - /// use bytes::BytesMut; - /// - /// // Allocate buffer big enough for 10 bytes. - /// let mut buf = BytesMut::with_capacity(10); - /// - /// // Fill in the first 3 elements. - /// let uninit = buf.spare_capacity_mut(); - /// uninit[0].write(0); - /// uninit[1].write(1); - /// uninit[2].write(2); - /// - /// // Mark the first 3 bytes of the buffer as being initialized. - /// unsafe { - /// buf.set_len(3); - /// } - /// - /// assert_eq!(&buf[..], &[0, 1, 2]); - /// ``` - #[inline] - pub fn spare_capacity_mut(&mut self) -> &mut [MaybeUninit<u8>] { - unsafe { - let ptr = self.ptr.as_ptr().add(self.len); - let len = self.cap - self.len; - - slice::from_raw_parts_mut(ptr.cast(), len) - } - } -} - -impl Drop for BytesMut { - fn drop(&mut self) { - let kind = self.kind(); - - if kind == KIND_VEC { - unsafe { - let off = self.get_vec_pos(); - - // Vector storage, free the vector - let _ = rebuild_vec(self.ptr.as_ptr(), self.len, self.cap, off); - } - } else if kind == KIND_ARC { - unsafe { release_shared(self.data) }; - } - } -} - -impl Buf for BytesMut { - #[inline] - fn remaining(&self) -> usize { - self.len() - } - - #[inline] - fn chunk(&self) -> &[u8] { - self.as_slice() - } - - #[inline] - fn advance(&mut self, cnt: usize) { - assert!( - cnt <= self.remaining(), - "cannot advance past `remaining`: {:?} <= {:?}", - cnt, - self.remaining(), - ); - unsafe { - // SAFETY: We've checked that `cnt` <= `self.remaining()` and we know that - // `self.remaining()` <= `self.cap`. - self.advance_unchecked(cnt); - } - } - - fn copy_to_bytes(&mut self, len: usize) -> Bytes { - self.split_to(len).freeze() - } -} - -unsafe impl BufMut for BytesMut { - #[inline] - fn remaining_mut(&self) -> usize { - usize::MAX - self.len() - } - - #[inline] - unsafe fn advance_mut(&mut self, cnt: usize) { - let remaining = self.cap - self.len(); - if cnt > remaining { - super::panic_advance(&TryGetError { - requested: cnt, - available: remaining, - }); - } - // Addition won't overflow since it is at most `self.cap`. - self.len = self.len() + cnt; - } - - #[inline] - fn chunk_mut(&mut self) -> &mut UninitSlice { - if self.capacity() == self.len() { - self.reserve(64); - } - self.spare_capacity_mut().into() - } - - // Specialize these methods so they can skip checking `remaining_mut` - // and `advance_mut`. - - fn put<T: Buf>(&mut self, mut src: T) - where - Self: Sized, - { - while src.has_remaining() { - let s = src.chunk(); - let l = s.len(); - self.extend_from_slice(s); - src.advance(l); - } - } - - fn put_slice(&mut self, src: &[u8]) { - self.extend_from_slice(src); - } - - fn put_bytes(&mut self, val: u8, cnt: usize) { - self.reserve(cnt); - unsafe { - let dst = self.spare_capacity_mut(); - // Reserved above - debug_assert!(dst.len() >= cnt); - - ptr::write_bytes(dst.as_mut_ptr(), val, cnt); - - self.advance_mut(cnt); - } - } -} - -impl AsRef<[u8]> for BytesMut { - #[inline] - fn as_ref(&self) -> &[u8] { - self.as_slice() - } -} - -impl Deref for BytesMut { - type Target = [u8]; - - #[inline] - fn deref(&self) -> &[u8] { - self.as_ref() - } -} - -impl AsMut<[u8]> for BytesMut { - #[inline] - fn as_mut(&mut self) -> &mut [u8] { - self.as_slice_mut() - } -} - -impl DerefMut for BytesMut { - #[inline] - fn deref_mut(&mut self) -> &mut [u8] { - self.as_mut() - } -} - -impl<'a> From<&'a [u8]> for BytesMut { - fn from(src: &'a [u8]) -> BytesMut { - BytesMut::from_vec(src.to_vec()) - } -} - -impl<'a> From<&'a str> for BytesMut { - fn from(src: &'a str) -> BytesMut { - BytesMut::from(src.as_bytes()) - } -} - -impl From<BytesMut> for Bytes { - fn from(src: BytesMut) -> Bytes { - src.freeze() - } -} - -impl PartialEq for BytesMut { - fn eq(&self, other: &BytesMut) -> bool { - self.as_slice() == other.as_slice() - } -} - -impl PartialOrd for BytesMut { - fn partial_cmp(&self, other: &BytesMut) -> Option<cmp::Ordering> { - self.as_slice().partial_cmp(other.as_slice()) - } -} - -impl Ord for BytesMut { - fn cmp(&self, other: &BytesMut) -> cmp::Ordering { - self.as_slice().cmp(other.as_slice()) - } -} - -impl Eq for BytesMut {} - -impl Default for BytesMut { - #[inline] - fn default() -> BytesMut { - BytesMut::new() - } -} - -impl hash::Hash for BytesMut { - fn hash<H>(&self, state: &mut H) - where - H: hash::Hasher, - { - let s: &[u8] = self.as_ref(); - s.hash(state); - } -} - -impl Borrow<[u8]> for BytesMut { - fn borrow(&self) -> &[u8] { - self.as_ref() - } -} - -impl BorrowMut<[u8]> for BytesMut { - fn borrow_mut(&mut self) -> &mut [u8] { - self.as_mut() - } -} - -impl fmt::Write for BytesMut { - #[inline] - fn write_str(&mut self, s: &str) -> fmt::Result { - if self.remaining_mut() >= s.len() { - self.put_slice(s.as_bytes()); - Ok(()) - } else { - Err(fmt::Error) - } - } - - #[inline] - fn write_fmt(&mut self, args: fmt::Arguments<'_>) -> fmt::Result { - fmt::write(self, args) - } -} - -impl Clone for BytesMut { - fn clone(&self) -> BytesMut { - BytesMut::from(&self[..]) - } -} - -impl IntoIterator for BytesMut { - type Item = u8; - type IntoIter = IntoIter<BytesMut>; - - fn into_iter(self) -> Self::IntoIter { - IntoIter::new(self) - } -} - -impl<'a> IntoIterator for &'a BytesMut { - type Item = &'a u8; - type IntoIter = core::slice::Iter<'a, u8>; - - fn into_iter(self) -> Self::IntoIter { - self.as_ref().iter() - } -} - -impl Extend<u8> for BytesMut { - fn extend<T>(&mut self, iter: T) - where - T: IntoIterator<Item = u8>, - { - let iter = iter.into_iter(); - - let (lower, _) = iter.size_hint(); - self.reserve(lower); - - // TODO: optimize - // 1. If self.kind() == KIND_VEC, use Vec::extend - for b in iter { - self.put_u8(b); - } - } -} - -impl<'a> Extend<&'a u8> for BytesMut { - fn extend<T>(&mut self, iter: T) - where - T: IntoIterator<Item = &'a u8>, - { - self.extend(iter.into_iter().copied()) - } -} - -impl Extend<Bytes> for BytesMut { - fn extend<T>(&mut self, iter: T) - where - T: IntoIterator<Item = Bytes>, - { - for bytes in iter { - self.extend_from_slice(&bytes) - } - } -} - -impl FromIterator<u8> for BytesMut { - fn from_iter<T: IntoIterator<Item = u8>>(into_iter: T) -> Self { - BytesMut::from_vec(Vec::from_iter(into_iter)) - } -} - -impl<'a> FromIterator<&'a u8> for BytesMut { - fn from_iter<T: IntoIterator<Item = &'a u8>>(into_iter: T) -> Self { - BytesMut::from_iter(into_iter.into_iter().copied()) - } -} - -/* - * - * ===== Inner ===== - * - */ - -unsafe fn increment_shared(ptr: *mut Shared) { - let old_size = (*ptr).ref_count.fetch_add(1, Ordering::Relaxed); - - if old_size > isize::MAX as usize { - crate::abort(); - } -} - -unsafe fn release_shared(ptr: *mut Shared) { - // `Shared` storage... follow the drop steps from Arc. - if (*ptr).ref_count.fetch_sub(1, Ordering::Release) != 1 { - return; - } - - // This fence is needed to prevent reordering of use of the data and - // deletion of the data. Because it is marked `Release`, the decreasing - // of the reference count synchronizes with this `Acquire` fence. This - // means that use of the data happens before decreasing the reference - // count, which happens before this fence, which happens before the - // deletion of the data. - // - // As explained in the [Boost documentation][1], - // - // > It is important to enforce any possible access to the object in one - // > thread (through an existing reference) to *happen before* deleting - // > the object in a different thread. This is achieved by a "release" - // > operation after dropping a reference (any access to the object - // > through this reference must obviously happened before), and an - // > "acquire" operation before deleting the object. - // - // [1]: (www.boost.org/doc/libs/1_55_0/doc/html/atomic/usage_examples.html) - // - // Thread sanitizer does not support atomic fences. Use an atomic load - // instead. - (*ptr).ref_count.load(Ordering::Acquire); - - // Drop the data - drop(Box::from_raw(ptr)); -} - -impl Shared { - fn is_unique(&self) -> bool { - // 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_count` 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_count` is decremented. As such, - // this `Acquire` will guarantee that those mutations are - // visible to the current thread. - self.ref_count.load(Ordering::Acquire) == 1 - } -} - -#[inline] -fn original_capacity_to_repr(cap: usize) -> usize { - let width = PTR_WIDTH - ((cap >> MIN_ORIGINAL_CAPACITY_WIDTH).leading_zeros() as usize); - cmp::min( - width, - MAX_ORIGINAL_CAPACITY_WIDTH - MIN_ORIGINAL_CAPACITY_WIDTH, - ) -} - -fn original_capacity_from_repr(repr: usize) -> usize { - if repr == 0 { - return 0; - } - - 1 << (repr + (MIN_ORIGINAL_CAPACITY_WIDTH - 1)) -} - -#[cfg(test)] -mod tests { - use super::*; - - #[test] - fn test_original_capacity_to_repr() { - assert_eq!(original_capacity_to_repr(0), 0); - - let max_width = 32; - - for width in 1..(max_width + 1) { - let cap = 1 << width - 1; - - let expected = if width < MIN_ORIGINAL_CAPACITY_WIDTH { - 0 - } else if width < MAX_ORIGINAL_CAPACITY_WIDTH { - width - MIN_ORIGINAL_CAPACITY_WIDTH - } else { - MAX_ORIGINAL_CAPACITY_WIDTH - MIN_ORIGINAL_CAPACITY_WIDTH - }; - - assert_eq!(original_capacity_to_repr(cap), expected); - - if width > 1 { - assert_eq!(original_capacity_to_repr(cap + 1), expected); - } - - // MIN_ORIGINAL_CAPACITY_WIDTH must be bigger than 7 to pass tests below - if width == MIN_ORIGINAL_CAPACITY_WIDTH + 1 { - assert_eq!(original_capacity_to_repr(cap - 24), expected - 1); - assert_eq!(original_capacity_to_repr(cap + 76), expected); - } else if width == MIN_ORIGINAL_CAPACITY_WIDTH + 2 { - assert_eq!(original_capacity_to_repr(cap - 1), expected - 1); - assert_eq!(original_capacity_to_repr(cap - 48), expected - 1); - } - } - } - - #[test] - fn test_original_capacity_from_repr() { - assert_eq!(0, original_capacity_from_repr(0)); - - let min_cap = 1 << MIN_ORIGINAL_CAPACITY_WIDTH; - - assert_eq!(min_cap, original_capacity_from_repr(1)); - assert_eq!(min_cap * 2, original_capacity_from_repr(2)); - assert_eq!(min_cap * 4, original_capacity_from_repr(3)); - assert_eq!(min_cap * 8, original_capacity_from_repr(4)); - assert_eq!(min_cap * 16, original_capacity_from_repr(5)); - assert_eq!(min_cap * 32, original_capacity_from_repr(6)); - assert_eq!(min_cap * 64, original_capacity_from_repr(7)); - } -} - -unsafe impl Send for BytesMut {} -unsafe impl Sync for BytesMut {} - -/* - * - * ===== PartialEq / PartialOrd ===== - * - */ - -impl PartialEq<[u8]> for BytesMut { - fn eq(&self, other: &[u8]) -> bool { - &**self == other - } -} - -impl PartialOrd<[u8]> for BytesMut { - fn partial_cmp(&self, other: &[u8]) -> Option<cmp::Ordering> { - (**self).partial_cmp(other) - } -} - -impl PartialEq<BytesMut> for [u8] { - fn eq(&self, other: &BytesMut) -> bool { - *other == *self - } -} - -impl PartialOrd<BytesMut> for [u8] { - fn partial_cmp(&self, other: &BytesMut) -> Option<cmp::Ordering> { - <[u8] as PartialOrd<[u8]>>::partial_cmp(self, other) - } -} - -impl PartialEq<str> for BytesMut { - fn eq(&self, other: &str) -> bool { - &**self == other.as_bytes() - } -} - -impl PartialOrd<str> for BytesMut { - fn partial_cmp(&self, other: &str) -> Option<cmp::Ordering> { - (**self).partial_cmp(other.as_bytes()) - } -} - -impl PartialEq<BytesMut> for str { - fn eq(&self, other: &BytesMut) -> bool { - *other == *self - } -} - -impl PartialOrd<BytesMut> for str { - fn partial_cmp(&self, other: &BytesMut) -> Option<cmp::Ordering> { - <[u8] as PartialOrd<[u8]>>::partial_cmp(self.as_bytes(), other) - } -} - -impl PartialEq<Vec<u8>> for BytesMut { - fn eq(&self, other: &Vec<u8>) -> bool { - *self == other[..] - } -} - -impl PartialOrd<Vec<u8>> for BytesMut { - fn partial_cmp(&self, other: &Vec<u8>) -> Option<cmp::Ordering> { - (**self).partial_cmp(&other[..]) - } -} - -impl PartialEq<BytesMut> for Vec<u8> { - fn eq(&self, other: &BytesMut) -> bool { - *other == *self - } -} - -impl PartialOrd<BytesMut> for Vec<u8> { - fn partial_cmp(&self, other: &BytesMut) -> Option<cmp::Ordering> { - other.partial_cmp(self) - } -} - -impl PartialEq<String> for BytesMut { - fn eq(&self, other: &String) -> bool { - *self == other[..] - } -} - -impl PartialOrd<String> for BytesMut { - fn partial_cmp(&self, other: &String) -> Option<cmp::Ordering> { - (**self).partial_cmp(other.as_bytes()) - } -} - -impl PartialEq<BytesMut> for String { - fn eq(&self, other: &BytesMut) -> bool { - *other == *self - } -} - -impl PartialOrd<BytesMut> for String { - fn partial_cmp(&self, other: &BytesMut) -> Option<cmp::Ordering> { - <[u8] as PartialOrd<[u8]>>::partial_cmp(self.as_bytes(), other) - } -} - -impl<'a, T: ?Sized> PartialEq<&'a T> for BytesMut -where - BytesMut: PartialEq<T>, -{ - fn eq(&self, other: &&'a T) -> bool { - *self == **other - } -} - -impl<'a, T: ?Sized> PartialOrd<&'a T> for BytesMut -where - BytesMut: PartialOrd<T>, -{ - fn partial_cmp(&self, other: &&'a T) -> Option<cmp::Ordering> { - self.partial_cmp(*other) - } -} - -impl PartialEq<BytesMut> for &[u8] { - fn eq(&self, other: &BytesMut) -> bool { - *other == *self - } -} - -impl PartialOrd<BytesMut> for &[u8] { - fn partial_cmp(&self, other: &BytesMut) -> Option<cmp::Ordering> { - <[u8] as PartialOrd<[u8]>>::partial_cmp(self, other) - } -} - -impl PartialEq<BytesMut> for &str { - fn eq(&self, other: &BytesMut) -> bool { - *other == *self - } -} - -impl PartialOrd<BytesMut> for &str { - fn partial_cmp(&self, other: &BytesMut) -> Option<cmp::Ordering> { - other.partial_cmp(self) - } -} - -impl PartialEq<BytesMut> for Bytes { - fn eq(&self, other: &BytesMut) -> bool { - other[..] == self[..] - } -} - -impl PartialEq<Bytes> for BytesMut { - fn eq(&self, other: &Bytes) -> bool { - other[..] == self[..] - } -} - -impl From<BytesMut> for Vec<u8> { - fn from(bytes: BytesMut) -> Self { - let kind = bytes.kind(); - let bytes = ManuallyDrop::new(bytes); - - let mut vec = if kind == KIND_VEC { - unsafe { - let off = bytes.get_vec_pos(); - rebuild_vec(bytes.ptr.as_ptr(), bytes.len, bytes.cap, off) - } - } else { - let shared = bytes.data as *mut Shared; - - if unsafe { (*shared).is_unique() } { - let vec = mem::replace(unsafe { &mut (*shared).vec }, Vec::new()); - - unsafe { release_shared(shared) }; - - vec - } else { - return ManuallyDrop::into_inner(bytes).deref().to_vec(); - } - }; - - let len = bytes.len; - - unsafe { - ptr::copy(bytes.ptr.as_ptr(), vec.as_mut_ptr(), len); - vec.set_len(len); - } - - vec - } -} - -#[inline] -fn vptr(ptr: *mut u8) -> NonNull<u8> { - if cfg!(debug_assertions) { - NonNull::new(ptr).expect("Vec pointer should be non-null") - } else { - unsafe { NonNull::new_unchecked(ptr) } - } -} - -/// Returns a dangling pointer with the given address. This is used to store -/// integer data in pointer fields. -/// -/// It is equivalent to `addr as *mut T`, but this fails on miri when strict -/// provenance checking is enabled. -#[inline] -fn invalid_ptr<T>(addr: usize) -> *mut T { - let ptr = core::ptr::null_mut::<u8>().wrapping_add(addr); - debug_assert_eq!(ptr as usize, addr); - ptr.cast::<T>() -} - -unsafe fn rebuild_vec(ptr: *mut u8, mut len: usize, mut cap: usize, off: usize) -> Vec<u8> { - let ptr = ptr.sub(off); - len += off; - cap += off; - - Vec::from_raw_parts(ptr, len, cap) -} - -// ===== impl SharedVtable ===== - -static SHARED_VTABLE: Vtable = Vtable { - clone: shared_v_clone, - to_vec: shared_v_to_vec, - to_mut: shared_v_to_mut, - is_unique: shared_v_is_unique, - drop: shared_v_drop, -}; - -unsafe fn shared_v_clone(data: &AtomicPtr<()>, ptr: *const u8, len: usize) -> Bytes { - let shared = data.load(Ordering::Relaxed) as *mut Shared; - increment_shared(shared); - - let data = AtomicPtr::new(shared as *mut ()); - Bytes::with_vtable(ptr, len, data, &SHARED_VTABLE) -} - -unsafe fn shared_v_to_vec(data: &AtomicPtr<()>, ptr: *const u8, len: usize) -> Vec<u8> { - let shared: *mut Shared = data.load(Ordering::Relaxed).cast(); - - if (*shared).is_unique() { - let shared = &mut *shared; - - // Drop shared - let mut vec = mem::replace(&mut shared.vec, Vec::new()); - release_shared(shared); - - // Copy back buffer - ptr::copy(ptr, vec.as_mut_ptr(), len); - vec.set_len(len); - - vec - } else { - let v = slice::from_raw_parts(ptr, len).to_vec(); - release_shared(shared); - v - } -} - -unsafe fn shared_v_to_mut(data: &AtomicPtr<()>, ptr: *const u8, len: usize) -> BytesMut { - let shared: *mut Shared = data.load(Ordering::Relaxed).cast(); - - if (*shared).is_unique() { - let shared = &mut *shared; - - // The capacity is always the original capacity of the buffer - // minus the offset from the start of the buffer - let v = &mut shared.vec; - let v_capacity = v.capacity(); - let v_ptr = v.as_mut_ptr(); - let offset = offset_from(ptr as *mut u8, v_ptr); - let cap = v_capacity - offset; - - let ptr = vptr(ptr as *mut u8); - - BytesMut { - ptr, - len, - cap, - data: shared, - } - } else { - let v = slice::from_raw_parts(ptr, len).to_vec(); - release_shared(shared); - BytesMut::from_vec(v) - } -} - -unsafe fn shared_v_is_unique(data: &AtomicPtr<()>) -> bool { - let shared = data.load(Ordering::Acquire); - let ref_count = (*shared.cast::<Shared>()).ref_count.load(Ordering::Relaxed); - ref_count == 1 -} - -unsafe fn shared_v_drop(data: &mut AtomicPtr<()>, _ptr: *const u8, _len: usize) { - data.with_mut(|shared| { - release_shared(*shared as *mut Shared); - }); -} - -// compile-fails - -/// ```compile_fail -/// use bytes::BytesMut; -/// #[deny(unused_must_use)] -/// { -/// let mut b1 = BytesMut::from("hello world"); -/// b1.split_to(6); -/// } -/// ``` -fn _split_to_must_use() {} - -/// ```compile_fail -/// use bytes::BytesMut; -/// #[deny(unused_must_use)] -/// { -/// let mut b1 = BytesMut::from("hello world"); -/// b1.split_off(6); -/// } -/// ``` -fn _split_off_must_use() {} - -/// ```compile_fail -/// use bytes::BytesMut; -/// #[deny(unused_must_use)] -/// { -/// let mut b1 = BytesMut::from("hello world"); -/// b1.split(); -/// } -/// ``` -fn _split_must_use() {} - -// fuzz tests -#[cfg(all(test, loom))] -mod fuzz { - use loom::sync::Arc; - use loom::thread; - - use super::BytesMut; - use crate::Bytes; - - #[test] - fn bytes_mut_cloning_frozen() { - loom::model(|| { - let a = BytesMut::from(&b"abcdefgh"[..]).split().freeze(); - let addr = a.as_ptr() as usize; - - // test the Bytes::clone is Sync by putting it in an Arc - let a1 = Arc::new(a); - let a2 = a1.clone(); - - let t1 = thread::spawn(move || { - let b: Bytes = (*a1).clone(); - assert_eq!(b.as_ptr() as usize, addr); - }); - - let t2 = thread::spawn(move || { - let b: Bytes = (*a2).clone(); - assert_eq!(b.as_ptr() as usize, addr); - }); - - t1.join().unwrap(); - t2.join().unwrap(); - }); - } -} diff --git a/vendor/bytes/src/fmt/debug.rs b/vendor/bytes/src/fmt/debug.rs deleted file mode 100644 index 82d0aa5e..00000000 --- a/vendor/bytes/src/fmt/debug.rs +++ /dev/null @@ -1,40 +0,0 @@ -use core::fmt::{Debug, Formatter, Result}; - -use super::BytesRef; -use crate::{Bytes, BytesMut}; - -/// Alternative implementation of `std::fmt::Debug` for byte slice. -/// -/// Standard `Debug` implementation for `[u8]` is comma separated -/// list of numbers. Since large amount of byte strings are in fact -/// ASCII strings or contain a lot of ASCII strings (e. g. HTTP), -/// it is convenient to print strings as ASCII when possible. -impl Debug for BytesRef<'_> { - fn fmt(&self, f: &mut Formatter<'_>) -> Result { - write!(f, "b\"")?; - for &b in self.0 { - // https://doc.rust-lang.org/reference/tokens.html#byte-escapes - if b == b'\n' { - write!(f, "\\n")?; - } else if b == b'\r' { - write!(f, "\\r")?; - } else if b == b'\t' { - write!(f, "\\t")?; - } else if b == b'\\' || b == b'"' { - write!(f, "\\{}", b as char)?; - } else if b == b'\0' { - write!(f, "\\0")?; - // ASCII printable - } else if (0x20..0x7f).contains(&b) { - write!(f, "{}", b as char)?; - } else { - write!(f, "\\x{:02x}", b)?; - } - } - write!(f, "\"")?; - Ok(()) - } -} - -fmt_impl!(Debug, Bytes); -fmt_impl!(Debug, BytesMut); diff --git a/vendor/bytes/src/fmt/hex.rs b/vendor/bytes/src/fmt/hex.rs deleted file mode 100644 index 1203b419..00000000 --- a/vendor/bytes/src/fmt/hex.rs +++ /dev/null @@ -1,27 +0,0 @@ -use core::fmt::{Formatter, LowerHex, Result, UpperHex}; - -use super::BytesRef; -use crate::{Bytes, BytesMut}; - -impl LowerHex for BytesRef<'_> { - fn fmt(&self, f: &mut Formatter<'_>) -> Result { - for &b in self.0 { - write!(f, "{:02x}", b)?; - } - Ok(()) - } -} - -impl UpperHex for BytesRef<'_> { - fn fmt(&self, f: &mut Formatter<'_>) -> Result { - for &b in self.0 { - write!(f, "{:02X}", b)?; - } - Ok(()) - } -} - -fmt_impl!(LowerHex, Bytes); -fmt_impl!(LowerHex, BytesMut); -fmt_impl!(UpperHex, Bytes); -fmt_impl!(UpperHex, BytesMut); diff --git a/vendor/bytes/src/fmt/mod.rs b/vendor/bytes/src/fmt/mod.rs deleted file mode 100644 index b8a0eafa..00000000 --- a/vendor/bytes/src/fmt/mod.rs +++ /dev/null @@ -1,15 +0,0 @@ -macro_rules! fmt_impl { - ($tr:ident, $ty:ty) => { - impl $tr for $ty { - fn fmt(&self, f: &mut Formatter<'_>) -> Result { - $tr::fmt(&BytesRef(self.as_ref()), f) - } - } - }; -} - -mod debug; -mod hex; - -/// `BytesRef` is not a part of public API of bytes crate. -struct BytesRef<'a>(&'a [u8]); diff --git a/vendor/bytes/src/lib.rs b/vendor/bytes/src/lib.rs deleted file mode 100644 index 08c42494..00000000 --- a/vendor/bytes/src/lib.rs +++ /dev/null @@ -1,199 +0,0 @@ -#![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)) -))] -#![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 -//! implementations ([`Buf`], [`BufMut`]). -//! -//! # `Bytes` -//! -//! `Bytes` is an efficient container for storing and operating on contiguous -//! slices of memory. It is intended for use primarily in networking code, but -//! could have applications elsewhere as well. -//! -//! `Bytes` values facilitate zero-copy network programming by allowing multiple -//! `Bytes` objects to point to the same underlying memory. This is managed by -//! using a reference count to track when the memory is no longer needed and can -//! be freed. -//! -//! A `Bytes` handle can be created directly from an existing byte store (such as `&[u8]` -//! or `Vec<u8>`), but usually a `BytesMut` is used first and written to. For -//! example: -//! -//! ```rust -//! use bytes::{BytesMut, BufMut}; -//! -//! let mut buf = BytesMut::with_capacity(1024); -//! buf.put(&b"hello world"[..]); -//! buf.put_u16(1234); -//! -//! let a = buf.split(); -//! assert_eq!(a, b"hello world\x04\xD2"[..]); -//! -//! buf.put(&b"goodbye world"[..]); -//! -//! let b = buf.split(); -//! assert_eq!(b, b"goodbye world"[..]); -//! -//! assert_eq!(buf.capacity(), 998); -//! ``` -//! -//! In the above example, only a single buffer of 1024 is allocated. The handles -//! `a` and `b` will share the underlying buffer and maintain indices tracking -//! the view into the buffer represented by the handle. -//! -//! See the [struct docs](`Bytes`) for more details. -//! -//! # `Buf`, `BufMut` -//! -//! These two traits provide read and write access to buffers. The underlying -//! storage may or may not be in contiguous memory. For example, `Bytes` is a -//! buffer that guarantees contiguous memory, but a [rope] stores the bytes in -//! disjoint chunks. `Buf` and `BufMut` maintain cursors tracking the current -//! position in the underlying byte storage. When bytes are read or written, the -//! cursor is advanced. -//! -//! [rope]: https://en.wikipedia.org/wiki/Rope_(data_structure) -//! -//! ## Relation with `Read` and `Write` -//! -//! At first glance, it may seem that `Buf` and `BufMut` overlap in -//! functionality with [`std::io::Read`] and [`std::io::Write`]. However, they -//! serve different purposes. A buffer is the value that is provided as an -//! argument to `Read::read` and `Write::write`. `Read` and `Write` may then -//! perform a syscall, which has the potential of failing. Operations on `Buf` -//! and `BufMut` are infallible. - -extern crate alloc; - -#[cfg(feature = "std")] -extern crate std; - -pub mod buf; -pub use crate::buf::{Buf, BufMut}; - -mod bytes; -mod bytes_mut; -mod fmt; -mod loom; -pub use crate::bytes::Bytes; -pub use crate::bytes_mut::BytesMut; - -// Optional Serde support -#[cfg(feature = "serde")] -mod serde; - -#[inline(never)] -#[cold] -fn abort() -> ! { - #[cfg(feature = "std")] - { - std::process::abort(); - } - - #[cfg(not(feature = "std"))] - { - struct Abort; - impl Drop for Abort { - fn drop(&mut self) { - panic!(); - } - } - let _a = Abort; - panic!("abort"); - } -} - -#[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, - } -} - -/// Error type for the `try_get_` methods of [`Buf`]. -/// Indicates that there were not enough remaining -/// bytes in the buffer while attempting -/// to get a value from a [`Buf`] with one -/// of the `try_get_` methods. -#[derive(Debug, PartialEq, Eq)] -pub struct TryGetError { - /// The number of bytes necessary to get the value - pub requested: usize, - - /// The number of bytes available in the buffer - pub available: usize, -} - -impl core::fmt::Display for TryGetError { - fn fmt(&self, f: &mut core::fmt::Formatter<'_>) -> Result<(), core::fmt::Error> { - write!( - f, - "Not enough bytes remaining in buffer to read value (requested {} but only {} available)", - self.requested, - self.available - ) - } -} - -#[cfg(feature = "std")] -impl std::error::Error for TryGetError {} - -#[cfg(feature = "std")] -impl From<TryGetError> for std::io::Error { - fn from(error: TryGetError) -> Self { - std::io::Error::new(std::io::ErrorKind::Other, error) - } -} - -/// Panic with a nice error message. -#[cold] -fn panic_advance(error_info: &TryGetError) -> ! { - panic!( - "advance out of bounds: the len is {} but advancing by {}", - error_info.available, error_info.requested - ); -} - -#[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 -} diff --git a/vendor/bytes/src/loom.rs b/vendor/bytes/src/loom.rs deleted file mode 100644 index c8092909..00000000 --- a/vendor/bytes/src/loom.rs +++ /dev/null @@ -1,33 +0,0 @@ -#[cfg(not(all(test, loom)))] -pub(crate) mod sync { - pub(crate) mod atomic { - #[cfg(not(feature = "extra-platforms"))] - pub(crate) use core::sync::atomic::{AtomicPtr, AtomicUsize, Ordering}; - #[cfg(feature = "extra-platforms")] - pub(crate) use extra_platforms::{AtomicPtr, AtomicUsize, Ordering}; - - pub(crate) trait AtomicMut<T> { - fn with_mut<F, R>(&mut self, f: F) -> R - where - F: FnOnce(&mut *mut T) -> R; - } - - impl<T> AtomicMut<T> for AtomicPtr<T> { - fn with_mut<F, R>(&mut self, f: F) -> R - where - F: FnOnce(&mut *mut T) -> R, - { - f(self.get_mut()) - } - } - } -} - -#[cfg(all(test, loom))] -pub(crate) mod sync { - pub(crate) mod atomic { - pub(crate) use loom::sync::atomic::{AtomicPtr, AtomicUsize, Ordering}; - - pub(crate) trait AtomicMut<T> {} - } -} diff --git a/vendor/bytes/src/serde.rs b/vendor/bytes/src/serde.rs deleted file mode 100644 index 0a5bd144..00000000 --- a/vendor/bytes/src/serde.rs +++ /dev/null @@ -1,89 +0,0 @@ -use super::{Bytes, BytesMut}; -use alloc::string::String; -use alloc::vec::Vec; -use core::{cmp, fmt}; -use serde::{de, Deserialize, Deserializer, Serialize, Serializer}; - -macro_rules! serde_impl { - ($ty:ident, $visitor_ty:ident, $from_slice:ident, $from_vec:ident) => { - impl Serialize for $ty { - #[inline] - fn serialize<S>(&self, serializer: S) -> Result<S::Ok, S::Error> - where - S: Serializer, - { - serializer.serialize_bytes(&self) - } - } - - struct $visitor_ty; - - impl<'de> de::Visitor<'de> for $visitor_ty { - type Value = $ty; - - fn expecting(&self, formatter: &mut fmt::Formatter<'_>) -> fmt::Result { - formatter.write_str("byte array") - } - - #[inline] - fn visit_seq<V>(self, mut seq: V) -> Result<Self::Value, V::Error> - where - V: de::SeqAccess<'de>, - { - let len = cmp::min(seq.size_hint().unwrap_or(0), 4096); - let mut values: Vec<u8> = Vec::with_capacity(len); - - while let Some(value) = seq.next_element()? { - values.push(value); - } - - Ok($ty::$from_vec(values)) - } - - #[inline] - fn visit_bytes<E>(self, v: &[u8]) -> Result<Self::Value, E> - where - E: de::Error, - { - Ok($ty::$from_slice(v)) - } - - #[inline] - fn visit_byte_buf<E>(self, v: Vec<u8>) -> Result<Self::Value, E> - where - E: de::Error, - { - Ok($ty::$from_vec(v)) - } - - #[inline] - fn visit_str<E>(self, v: &str) -> Result<Self::Value, E> - where - E: de::Error, - { - Ok($ty::$from_slice(v.as_bytes())) - } - - #[inline] - fn visit_string<E>(self, v: String) -> Result<Self::Value, E> - where - E: de::Error, - { - Ok($ty::$from_vec(v.into_bytes())) - } - } - - impl<'de> Deserialize<'de> for $ty { - #[inline] - fn deserialize<D>(deserializer: D) -> Result<$ty, D::Error> - where - D: Deserializer<'de>, - { - deserializer.deserialize_byte_buf($visitor_ty) - } - } - }; -} - -serde_impl!(Bytes, BytesVisitor, copy_from_slice, from); -serde_impl!(BytesMut, BytesMutVisitor, from, from_vec); diff --git a/vendor/bytes/tests/test_buf.rs b/vendor/bytes/tests/test_buf.rs deleted file mode 100644 index 099016e2..00000000 --- a/vendor/bytes/tests/test_buf.rs +++ /dev/null @@ -1,439 +0,0 @@ -#![warn(rust_2018_idioms)] - -use ::bytes::{Buf, Bytes, BytesMut}; -use core::{cmp, mem}; -use std::collections::VecDeque; -#[cfg(feature = "std")] -use std::io::IoSlice; - -// A random 64-byte ascii string, with the first 8 bytes altered to -// give valid representations of f32 and f64 (making them easier to compare) -// and negative signed numbers when interpreting as big endian -// (testing Sign Extension for `Buf::get_int' and `Buf::get_int_ne`). -const INPUT: &[u8] = b"\xffFqrjrDqPhvTc45vvq33f6bJrUtyHESuTeklWKgYd64xgzxJwvAkpYYnpNJyZSRn"; - -macro_rules! e { - ($big_endian_val:expr, $little_endian_val:expr) => { - if cfg!(target_endian = "big") { - $big_endian_val - } else { - $little_endian_val - } - }; -} - -macro_rules! buf_tests { - ($make_input:ident) => { - buf_tests!($make_input, true); - }; - ($make_input:ident, $checks_vectored_is_complete:expr) => { - use super::*; - - #[test] - fn empty_state() { - let buf = $make_input(&[]); - assert_eq!(buf.remaining(), 0); - assert!(!buf.has_remaining()); - assert!(buf.chunk().is_empty()); - } - - #[test] - fn fresh_state() { - let buf = $make_input(INPUT); - assert_eq!(buf.remaining(), 64); - assert!(buf.has_remaining()); - - let chunk = buf.chunk(); - assert!(chunk.len() <= 64); - assert!(INPUT.starts_with(chunk)); - } - - #[test] - fn advance() { - let mut buf = $make_input(INPUT); - buf.advance(8); - assert_eq!(buf.remaining(), 64 - 8); - assert!(buf.has_remaining()); - - let chunk = buf.chunk(); - assert!(chunk.len() <= 64 - 8); - assert!(INPUT[8..].starts_with(chunk)); - } - - #[test] - fn advance_to_end() { - let mut buf = $make_input(INPUT); - buf.advance(64); - assert_eq!(buf.remaining(), 0); - assert!(!buf.has_remaining()); - - let chunk = buf.chunk(); - assert!(chunk.is_empty()); - } - - #[test] - #[should_panic] - fn advance_past_end() { - let mut buf = $make_input(INPUT); - buf.advance(65); - } - - #[test] - #[cfg(feature = "std")] - fn chunks_vectored_empty() { - let buf = $make_input(&[]); - let mut bufs = [IoSlice::new(&[]); 16]; - - let n = buf.chunks_vectored(&mut bufs); - assert_eq!(n, 0); - assert!(bufs.iter().all(|buf| buf.is_empty())); - } - - #[test] - #[cfg(feature = "std")] - fn chunks_vectored_is_complete() { - let buf = $make_input(INPUT); - let mut bufs = [IoSlice::new(&[]); 16]; - - let n = buf.chunks_vectored(&mut bufs); - assert!(n > 0); - assert!(n <= 16); - - let bufs_concat = bufs[..n] - .iter() - .flat_map(|b| b.iter().copied()) - .collect::<Vec<u8>>(); - if $checks_vectored_is_complete { - assert_eq!(bufs_concat, INPUT); - } else { - // If this panics then `buf` implements `chunks_vectored`. - // Remove the `false` argument from `buf_tests!` for that type. - assert!(bufs_concat.len() < INPUT.len()); - assert!(INPUT.starts_with(&bufs_concat)); - } - - for i in n..16 { - assert!(bufs[i].is_empty()); - } - } - - #[test] - fn copy_to_slice() { - let mut buf = $make_input(INPUT); - - let mut chunk = [0u8; 8]; - buf.copy_to_slice(&mut chunk); - assert_eq!(buf.remaining(), 64 - 8); - assert!(buf.has_remaining()); - assert_eq!(chunk, INPUT[..8]); - - let chunk = buf.chunk(); - assert!(chunk.len() <= 64 - 8); - assert!(INPUT[8..].starts_with(chunk)); - } - - #[test] - fn copy_to_slice_big() { - let mut buf = $make_input(INPUT); - - let mut chunk = [0u8; 56]; - buf.copy_to_slice(&mut chunk); - assert_eq!(buf.remaining(), 64 - 56); - assert!(buf.has_remaining()); - assert_eq!(chunk, INPUT[..56]); - - let chunk = buf.chunk(); - assert!(chunk.len() <= 64 - 56); - assert!(INPUT[56..].starts_with(chunk)); - } - - #[test] - fn copy_to_slice_to_end() { - let mut buf = $make_input(INPUT); - - let mut chunk = [0u8; 64]; - buf.copy_to_slice(&mut chunk); - assert_eq!(buf.remaining(), 0); - assert!(!buf.has_remaining()); - assert_eq!(chunk, INPUT); - - assert!(buf.chunk().is_empty()); - } - - #[test] - #[should_panic] - fn copy_to_slice_overflow() { - let mut buf = $make_input(INPUT); - - let mut chunk = [0u8; 65]; - buf.copy_to_slice(&mut chunk); - } - - #[test] - fn copy_to_bytes() { - let mut buf = $make_input(INPUT); - - let chunk = buf.copy_to_bytes(8); - assert_eq!(buf.remaining(), 64 - 8); - assert!(buf.has_remaining()); - assert_eq!(chunk, INPUT[..8]); - - let chunk = buf.chunk(); - assert!(chunk.len() <= 64 - 8); - assert!(INPUT[8..].starts_with(chunk)); - } - - #[test] - fn copy_to_bytes_big() { - let mut buf = $make_input(INPUT); - - let chunk = buf.copy_to_bytes(56); - assert_eq!(buf.remaining(), 64 - 56); - assert!(buf.has_remaining()); - assert_eq!(chunk, INPUT[..56]); - - let chunk = buf.chunk(); - assert!(chunk.len() <= 64 - 56); - assert!(INPUT[56..].starts_with(chunk)); - } - - #[test] - fn copy_to_bytes_to_end() { - let mut buf = $make_input(INPUT); - - let chunk = buf.copy_to_bytes(64); - assert_eq!(buf.remaining(), 0); - assert!(!buf.has_remaining()); - assert_eq!(chunk, INPUT); - - assert!(buf.chunk().is_empty()); - } - - #[test] - #[should_panic] - fn copy_to_bytes_overflow() { - let mut buf = $make_input(INPUT); - - let _ = buf.copy_to_bytes(65); - } - - buf_tests!(number $make_input, get_u8, get_u8_overflow, u8, get_u8, 0xff); - buf_tests!(number $make_input, get_i8, get_i8_overflow, i8, get_i8, 0xffu8 as i8); - buf_tests!(number $make_input, get_u16_be, get_u16_be_overflow, u16, get_u16, 0xff46); - buf_tests!(number $make_input, get_u16_le, get_u16_le_overflow, u16, get_u16_le, 0x46ff); - buf_tests!(number $make_input, get_u16_ne, get_u16_ne_overflow, u16, get_u16_ne, e!(0xff46, 0x46ff)); - buf_tests!(number $make_input, get_i16_be, get_i16_be_overflow, i16, get_i16, 0xff46u16 as i16); - buf_tests!(number $make_input, get_i16_le, get_i16_le_overflow, i16, get_i16_le, 0x46ff); - buf_tests!(number $make_input, get_i16_ne, get_i16_ne_overflow, i16, get_i16_ne, e!(0xff46u16 as i16, 0x46ff)); - buf_tests!(number $make_input, get_u32_be, get_u32_be_overflow, u32, get_u32, 0xff467172); - buf_tests!(number $make_input, get_u32_le, get_u32_le_overflow, u32, get_u32_le, 0x727146ff); - buf_tests!(number $make_input, get_u32_ne, get_u32_ne_overflow, u32, get_u32_ne, e!(0xff467172, 0x727146ff)); - buf_tests!(number $make_input, get_i32_be, get_i32_be_overflow, i32, get_i32, 0xff467172u32 as i32); - buf_tests!(number $make_input, get_i32_le, get_i32_le_overflow, i32, get_i32_le, 0x727146ff); - buf_tests!(number $make_input, get_i32_ne, get_i32_ne_overflow, i32, get_i32_ne, e!(0xff467172u32 as i32, 0x727146ff)); - buf_tests!(number $make_input, get_u64_be, get_u64_be_overflow, u64, get_u64, 0xff4671726a724471); - buf_tests!(number $make_input, get_u64_le, get_u64_le_overflow, u64, get_u64_le, 0x7144726a727146ff); - buf_tests!(number $make_input, get_u64_ne, get_u64_ne_overflow, u64, get_u64_ne, e!(0xff4671726a724471, 0x7144726a727146ff)); - buf_tests!(number $make_input, get_i64_be, get_i64_be_overflow, i64, get_i64, 0xff4671726a724471u64 as i64); - buf_tests!(number $make_input, get_i64_le, get_i64_le_overflow, i64, get_i64_le, 0x7144726a727146ff); - buf_tests!(number $make_input, get_i64_ne, get_i64_ne_overflow, i64, get_i64_ne, e!(0xff4671726a724471u64 as i64, 0x7144726a727146ff)); - buf_tests!(number $make_input, get_u128_be, get_u128_be_overflow, u128, get_u128, 0xff4671726a7244715068765463343576); - buf_tests!(number $make_input, get_u128_le, get_u128_le_overflow, u128, get_u128_le, 0x76353463547668507144726a727146ff); - buf_tests!(number $make_input, get_u128_ne, get_u128_ne_overflow, u128, get_u128_ne, e!(0xff4671726a7244715068765463343576, 0x76353463547668507144726a727146ff)); - buf_tests!(number $make_input, get_i128_be, get_i128_be_overflow, i128, get_i128, 0xff4671726a7244715068765463343576u128 as i128); - buf_tests!(number $make_input, get_i128_le, get_i128_le_overflow, i128, get_i128_le, 0x76353463547668507144726a727146ff); - buf_tests!(number $make_input, get_i128_ne, get_i128_ne_overflow, i128, get_i128_ne, e!(0xff4671726a7244715068765463343576u128 as i128, 0x76353463547668507144726a727146ff)); - buf_tests!(number $make_input, get_f32_be, get_f32_be_overflow, f32, get_f32, f32::from_bits(0xff467172)); - buf_tests!(number $make_input, get_f32_le, get_f32_le_overflow, f32, get_f32_le, f32::from_bits(0x727146ff)); - buf_tests!(number $make_input, get_f32_ne, get_f32_ne_overflow, f32, get_f32_ne, f32::from_bits(e!(0xff467172, 0x727146ff))); - buf_tests!(number $make_input, get_f64_be, get_f64_be_overflow, f64, get_f64, f64::from_bits(0xff4671726a724471)); - buf_tests!(number $make_input, get_f64_le, get_f64_le_overflow, f64, get_f64_le, f64::from_bits(0x7144726a727146ff)); - buf_tests!(number $make_input, get_f64_ne, get_f64_ne_overflow, f64, get_f64_ne, f64::from_bits(e!(0xff4671726a724471, 0x7144726a727146ff))); - - buf_tests!(var_number $make_input, get_uint_be, get_uint_be_overflow, u64, get_uint, 3, 0xff4671); - buf_tests!(var_number $make_input, get_uint_le, get_uint_le_overflow, u64, get_uint_le, 3, 0x7146ff); - buf_tests!(var_number $make_input, get_uint_ne, get_uint_ne_overflow, u64, get_uint_ne, 3, e!(0xff4671, 0x7146ff)); - buf_tests!(var_number $make_input, get_int_be, get_int_be_overflow, i64, get_int, 3, 0xffffffffffff4671u64 as i64); - buf_tests!(var_number $make_input, get_int_le, get_int_le_overflow, i64, get_int_le, 3, 0x7146ff); - buf_tests!(var_number $make_input, get_int_ne, get_int_ne_overflow, i64, get_int_ne, 3, e!(0xffffffffffff4671u64 as i64, 0x7146ff)); - }; - (number $make_input:ident, $ok_name:ident, $panic_name:ident, $number:ty, $method:ident, $value:expr) => { - #[test] - fn $ok_name() { - let mut buf = $make_input(INPUT); - - let value = buf.$method(); - assert_eq!(buf.remaining(), 64 - mem::size_of::<$number>()); - assert!(buf.has_remaining()); - assert_eq!(value, $value); - } - - #[test] - #[should_panic] - fn $panic_name() { - let mut buf = $make_input(&[]); - - let _ = buf.$method(); - } - }; - (var_number $make_input:ident, $ok_name:ident, $panic_name:ident, $number:ty, $method:ident, $len:expr, $value:expr) => { - #[test] - fn $ok_name() { - let mut buf = $make_input(INPUT); - - let value = buf.$method($len); - assert_eq!(buf.remaining(), 64 - $len); - assert!(buf.has_remaining()); - assert_eq!(value, $value); - } - - #[test] - #[should_panic] - fn $panic_name() { - let mut buf = $make_input(&[]); - - let _ = buf.$method($len); - } - }; -} - -mod u8_slice { - fn make_input(buf: &'static [u8]) -> &'static [u8] { - buf - } - - buf_tests!(make_input); -} - -mod bytes { - fn make_input(buf: &'static [u8]) -> impl Buf { - Bytes::from_static(buf) - } - - buf_tests!(make_input); -} - -mod bytes_mut { - fn make_input(buf: &'static [u8]) -> impl Buf { - BytesMut::from(buf) - } - - buf_tests!(make_input); -} - -mod vec_deque { - fn make_input(buf: &'static [u8]) -> impl Buf { - let mut deque = VecDeque::new(); - - if !buf.is_empty() { - // Construct |b|some bytes|a| `VecDeque` - let mid = buf.len() / 2; - let (a, b) = buf.split_at(mid); - - deque.reserve_exact(buf.len() + 1); - - let extra_space = deque.capacity() - b.len() - 1; - deque.resize(extra_space, 0); - - deque.extend(a); - deque.drain(..extra_space); - deque.extend(b); - - let (a, b) = deque.as_slices(); - assert!( - !a.is_empty(), - "could not setup test - attempt to create discontiguous VecDeque failed" - ); - assert!( - !b.is_empty(), - "could not setup test - attempt to create discontiguous VecDeque failed" - ); - } - - deque - } - - buf_tests!(make_input, true); -} - -#[cfg(feature = "std")] -mod cursor { - use std::io::Cursor; - - fn make_input(buf: &'static [u8]) -> impl Buf { - Cursor::new(buf) - } - - buf_tests!(make_input); -} - -mod box_bytes { - fn make_input(buf: &'static [u8]) -> impl Buf { - Box::new(Bytes::from_static(buf)) - } - - buf_tests!(make_input); -} - -mod chain_u8_slice { - fn make_input(buf: &'static [u8]) -> impl Buf { - let (a, b) = buf.split_at(buf.len() / 2); - Buf::chain(a, b) - } - - buf_tests!(make_input); -} - -mod chain_small_big_u8_slice { - fn make_input(buf: &'static [u8]) -> impl Buf { - let mid = cmp::min(1, buf.len()); - let (a, b) = buf.split_at(mid); - Buf::chain(a, b) - } - - buf_tests!(make_input); -} - -mod chain_limited_slices { - fn make_input(buf: &'static [u8]) -> impl Buf { - let buf3 = &buf[cmp::min(buf.len(), 3)..]; - let a = Buf::take(buf3, 0); - let b = Buf::take(buf, 3); - let c = Buf::take(buf3, usize::MAX); - let d = buf; - Buf::take(Buf::chain(Buf::chain(a, b), Buf::chain(c, d)), buf.len()) - } - - buf_tests!(make_input, true); -} - -#[allow(unused_allocation)] // This is intentional. -#[test] -fn test_deref_buf_forwards() { - struct Special; - - impl Buf for Special { - fn remaining(&self) -> usize { - unreachable!("remaining"); - } - - fn chunk(&self) -> &[u8] { - unreachable!("chunk"); - } - - fn advance(&mut self, _: usize) { - unreachable!("advance"); - } - - fn get_u8(&mut self) -> u8 { - // specialized! - b'x' - } - } - - // these should all use the specialized method - assert_eq!(Special.get_u8(), b'x'); - assert_eq!((&mut Special as &mut dyn Buf).get_u8(), b'x'); - assert_eq!((Box::new(Special) as Box<dyn Buf>).get_u8(), b'x'); - assert_eq!(Box::new(Special).get_u8(), b'x'); -} diff --git a/vendor/bytes/tests/test_buf_mut.rs b/vendor/bytes/tests/test_buf_mut.rs deleted file mode 100644 index 0abeb9f7..00000000 --- a/vendor/bytes/tests/test_buf_mut.rs +++ /dev/null @@ -1,276 +0,0 @@ -#![warn(rust_2018_idioms)] - -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!(buf.chunk_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.capacity(), 64); - - for _ in 0..16 { - buf.put(&b"zomg"[..]); - } - - 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); - buf.put_u8(33); - assert_eq!(b"\x21", &buf[..]); -} - -#[test] -fn test_put_u16() { - let mut buf = Vec::with_capacity(8); - buf.put_u16(8532); - assert_eq!(b"\x21\x54", &buf[..]); - - buf.clear(); - buf.put_u16_le(8532); - assert_eq!(b"\x54\x21", &buf[..]); -} - -#[test] -fn test_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")] -fn test_vec_advance_mut() { - // Verify fix for #354 - let mut buf = Vec::with_capacity(8); - unsafe { - buf.advance_mut(12); - } -} - -#[test] -fn test_clone() { - let mut buf = BytesMut::with_capacity(100); - buf.write_str("this is a test").unwrap(); - let buf2 = buf.clone(); - - buf.write_str(" of our emergency broadcast system").unwrap(); - assert!(buf != buf2); -} - -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); -} - -#[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; - - unsafe impl BufMut for Special { - fn remaining_mut(&self) -> usize { - unreachable!("remaining_mut"); - } - - fn chunk_mut(&mut self) -> &mut UninitSlice { - unreachable!("chunk_mut"); - } - - unsafe fn advance_mut(&mut self, _: usize) { - unreachable!("advance"); - } - - fn put_u8(&mut self, _: u8) { - // specialized! - } - } - - // these should all use the specialized method - Special.put_u8(b'x'); - (&mut Special as &mut dyn BufMut).put_u8(b'x'); - (Box::new(Special) as Box<dyn BufMut>).put_u8(b'x'); - Box::new(Special).put_u8(b'x'); -} - -#[test] -#[should_panic] -fn write_byte_panics_if_out_of_bounds() { - let mut data = [b'b', b'a', b'r']; - - let slice = unsafe { UninitSlice::from_raw_parts_mut(data.as_mut_ptr(), 3) }; - slice.write_byte(4, b'f'); -} - -#[test] -#[should_panic] -fn copy_from_slice_panics_if_different_length_1() { - let mut data = [b'b', b'a', b'r']; - - let slice = unsafe { UninitSlice::from_raw_parts_mut(data.as_mut_ptr(), 3) }; - slice.copy_from_slice(b"a"); -} - -#[test] -#[should_panic] -fn copy_from_slice_panics_if_different_length_2() { - let mut data = [b'b', b'a', b'r']; - - let slice = unsafe { UninitSlice::from_raw_parts_mut(data.as_mut_ptr(), 3) }; - slice.copy_from_slice(b"abcd"); -} diff --git a/vendor/bytes/tests/test_bytes.rs b/vendor/bytes/tests/test_bytes.rs deleted file mode 100644 index 613efc88..00000000 --- a/vendor/bytes/tests/test_bytes.rs +++ /dev/null @@ -1,1649 +0,0 @@ -#![warn(rust_2018_idioms)] - -use bytes::{Buf, BufMut, Bytes, BytesMut}; -use std::sync::atomic::{AtomicUsize, Ordering}; -use std::sync::Arc; - -use std::panic::{self, AssertUnwindSafe}; -use std::usize; - -const LONG: &[u8] = b"mary had a little lamb, little lamb, little lamb"; -const SHORT: &[u8] = b"hello world"; - -fn is_sync<T: Sync>() {} -fn is_send<T: Send>() {} - -#[test] -fn test_bounds() { - is_sync::<Bytes>(); - is_sync::<BytesMut>(); - is_send::<Bytes>(); - is_send::<BytesMut>(); -} - -#[test] -fn test_layout() { - use std::mem; - - assert_eq!( - mem::size_of::<Bytes>(), - mem::size_of::<usize>() * 4, - "Bytes size should be 4 words", - ); - assert_eq!( - mem::size_of::<BytesMut>(), - mem::size_of::<usize>() * 4, - "BytesMut should be 4 words", - ); - - assert_eq!( - mem::size_of::<Bytes>(), - mem::size_of::<Option<Bytes>>(), - "Bytes should be same size as Option<Bytes>", - ); - - assert_eq!( - mem::size_of::<BytesMut>(), - mem::size_of::<Option<BytesMut>>(), - "BytesMut should be same size as Option<BytesMut>", - ); -} - -#[test] -fn from_slice() { - let a = Bytes::from(&b"abcdefgh"[..]); - assert_eq!(a, b"abcdefgh"[..]); - assert_eq!(a, &b"abcdefgh"[..]); - assert_eq!(a, Vec::from(&b"abcdefgh"[..])); - assert_eq!(b"abcdefgh"[..], a); - assert_eq!(&b"abcdefgh"[..], a); - assert_eq!(Vec::from(&b"abcdefgh"[..]), a); - - let a = BytesMut::from(&b"abcdefgh"[..]); - assert_eq!(a, b"abcdefgh"[..]); - assert_eq!(a, &b"abcdefgh"[..]); - assert_eq!(a, Vec::from(&b"abcdefgh"[..])); - assert_eq!(b"abcdefgh"[..], a); - assert_eq!(&b"abcdefgh"[..], a); - assert_eq!(Vec::from(&b"abcdefgh"[..]), a); -} - -#[test] -fn fmt() { - let a = format!("{:?}", Bytes::from(&b"abcdefg"[..])); - let b = "b\"abcdefg\""; - - assert_eq!(a, b); - - let a = format!("{:?}", BytesMut::from(&b"abcdefg"[..])); - assert_eq!(a, b); -} - -#[test] -fn fmt_write() { - use std::fmt::Write; - use std::iter::FromIterator; - let s = String::from_iter((0..10).map(|_| "abcdefg")); - - let mut a = BytesMut::with_capacity(64); - write!(a, "{}", &s[..64]).unwrap(); - assert_eq!(a, s[..64].as_bytes()); - - let mut b = BytesMut::with_capacity(64); - write!(b, "{}", &s[..32]).unwrap(); - write!(b, "{}", &s[32..64]).unwrap(); - assert_eq!(b, s[..64].as_bytes()); - - let mut c = BytesMut::with_capacity(64); - write!(c, "{}", s).unwrap(); - assert_eq!(c, s[..].as_bytes()); -} - -#[test] -fn len() { - let a = Bytes::from(&b"abcdefg"[..]); - assert_eq!(a.len(), 7); - - let a = BytesMut::from(&b"abcdefg"[..]); - assert_eq!(a.len(), 7); - - let a = Bytes::from(&b""[..]); - assert!(a.is_empty()); - - let a = BytesMut::from(&b""[..]); - assert!(a.is_empty()); -} - -#[test] -fn index() { - let a = Bytes::from(&b"hello world"[..]); - assert_eq!(a[0..5], *b"hello"); -} - -#[test] -fn slice() { - let a = Bytes::from(&b"hello world"[..]); - - let b = a.slice(3..5); - assert_eq!(b, b"lo"[..]); - - let b = a.slice(0..0); - assert_eq!(b, b""[..]); - - let b = a.slice(3..3); - assert_eq!(b, b""[..]); - - let b = a.slice(a.len()..a.len()); - assert_eq!(b, b""[..]); - - let b = a.slice(..5); - assert_eq!(b, b"hello"[..]); - - let b = a.slice(3..); - assert_eq!(b, b"lo world"[..]); -} - -#[test] -#[should_panic] -fn slice_oob_1() { - let a = Bytes::from(&b"hello world"[..]); - a.slice(5..44); -} - -#[test] -#[should_panic] -fn slice_oob_2() { - let a = Bytes::from(&b"hello world"[..]); - a.slice(44..49); -} - -#[test] -fn split_off() { - let mut hello = Bytes::from(&b"helloworld"[..]); - let world = hello.split_off(5); - - assert_eq!(hello, &b"hello"[..]); - assert_eq!(world, &b"world"[..]); - - let mut hello = BytesMut::from(&b"helloworld"[..]); - let world = hello.split_off(5); - - assert_eq!(hello, &b"hello"[..]); - assert_eq!(world, &b"world"[..]); -} - -#[test] -#[should_panic] -fn split_off_oob() { - let mut hello = Bytes::from(&b"helloworld"[..]); - let _ = hello.split_off(44); -} - -#[test] -fn split_off_uninitialized() { - let mut bytes = BytesMut::with_capacity(1024); - let other = bytes.split_off(128); - - assert_eq!(bytes.len(), 0); - assert_eq!(bytes.capacity(), 128); - - assert_eq!(other.len(), 0); - assert_eq!(other.capacity(), 896); -} - -#[test] -fn split_off_to_loop() { - let s = b"abcdefghijklmnopqrstuvwxyzABCDEFGHIJKLMNOPQRSTUVWXYZ"; - - for i in 0..(s.len() + 1) { - { - let mut bytes = Bytes::from(&s[..]); - let off = bytes.split_off(i); - assert_eq!(i, bytes.len()); - let mut sum = Vec::new(); - sum.extend(bytes.iter()); - sum.extend(off.iter()); - assert_eq!(&s[..], &sum[..]); - } - { - let mut bytes = BytesMut::from(&s[..]); - let off = bytes.split_off(i); - assert_eq!(i, bytes.len()); - let mut sum = Vec::new(); - sum.extend(&bytes); - sum.extend(&off); - assert_eq!(&s[..], &sum[..]); - } - { - let mut bytes = Bytes::from(&s[..]); - let off = bytes.split_to(i); - assert_eq!(i, off.len()); - let mut sum = Vec::new(); - sum.extend(off.iter()); - sum.extend(bytes.iter()); - assert_eq!(&s[..], &sum[..]); - } - { - let mut bytes = BytesMut::from(&s[..]); - let off = bytes.split_to(i); - assert_eq!(i, off.len()); - let mut sum = Vec::new(); - sum.extend(&off); - sum.extend(&bytes); - assert_eq!(&s[..], &sum[..]); - } - } -} - -#[test] -fn split_to_1() { - // Static - let mut a = Bytes::from_static(SHORT); - let b = a.split_to(4); - - assert_eq!(SHORT[4..], a); - assert_eq!(SHORT[..4], b); - - // Allocated - let mut a = Bytes::copy_from_slice(LONG); - let b = a.split_to(4); - - assert_eq!(LONG[4..], a); - assert_eq!(LONG[..4], b); - - let mut a = Bytes::copy_from_slice(LONG); - let b = a.split_to(30); - - assert_eq!(LONG[30..], a); - assert_eq!(LONG[..30], b); -} - -#[test] -fn split_to_2() { - let mut a = Bytes::from(LONG); - assert_eq!(LONG, a); - - let b = a.split_to(1); - - assert_eq!(LONG[1..], a); - drop(b); -} - -#[test] -#[should_panic] -fn split_to_oob() { - let mut hello = Bytes::from(&b"helloworld"[..]); - let _ = hello.split_to(33); -} - -#[test] -#[should_panic] -fn split_to_oob_mut() { - let mut hello = BytesMut::from(&b"helloworld"[..]); - let _ = hello.split_to(33); -} - -#[test] -#[should_panic] -fn split_to_uninitialized() { - let mut bytes = BytesMut::with_capacity(1024); - let _other = bytes.split_to(128); -} - -#[test] -#[cfg_attr(not(panic = "unwind"), ignore)] -fn split_off_to_at_gt_len() { - fn make_bytes() -> Bytes { - let mut bytes = BytesMut::with_capacity(100); - bytes.put_slice(&[10, 20, 30, 40]); - bytes.freeze() - } - - use std::panic; - - let _ = make_bytes().split_to(4); - let _ = make_bytes().split_off(4); - - assert!(panic::catch_unwind(move || { - let _ = make_bytes().split_to(5); - }) - .is_err()); - - assert!(panic::catch_unwind(move || { - let _ = make_bytes().split_off(5); - }) - .is_err()); -} - -#[test] -fn truncate() { - let s = &b"helloworld"[..]; - let mut hello = Bytes::from(s); - hello.truncate(15); - assert_eq!(hello, s); - hello.truncate(10); - assert_eq!(hello, s); - hello.truncate(5); - assert_eq!(hello, "hello"); -} - -#[test] -fn freeze_clone_shared() { - let s = &b"abcdefgh"[..]; - let b = BytesMut::from(s).split().freeze(); - assert_eq!(b, s); - let c = b.clone(); - assert_eq!(c, s); -} - -#[test] -fn freeze_clone_unique() { - let s = &b"abcdefgh"[..]; - let b = BytesMut::from(s).freeze(); - assert_eq!(b, s); - let c = b.clone(); - assert_eq!(c, s); -} - -#[test] -fn freeze_after_advance() { - let s = &b"abcdefgh"[..]; - let mut b = BytesMut::from(s); - b.advance(1); - assert_eq!(b, s[1..]); - let b = b.freeze(); - // Verify fix for #352. Previously, freeze would ignore the start offset - // for BytesMuts in Vec mode. - assert_eq!(b, s[1..]); -} - -#[test] -fn freeze_after_advance_arc() { - let s = &b"abcdefgh"[..]; - let mut b = BytesMut::from(s); - // Make b Arc - let _ = b.split_to(0); - b.advance(1); - assert_eq!(b, s[1..]); - let b = b.freeze(); - assert_eq!(b, s[1..]); -} - -#[test] -fn freeze_after_split_to() { - let s = &b"abcdefgh"[..]; - let mut b = BytesMut::from(s); - let _ = b.split_to(1); - assert_eq!(b, s[1..]); - let b = b.freeze(); - assert_eq!(b, s[1..]); -} - -#[test] -fn freeze_after_truncate() { - let s = &b"abcdefgh"[..]; - let mut b = BytesMut::from(s); - b.truncate(7); - assert_eq!(b, s[..7]); - let b = b.freeze(); - assert_eq!(b, s[..7]); -} - -#[test] -fn freeze_after_truncate_arc() { - let s = &b"abcdefgh"[..]; - let mut b = BytesMut::from(s); - // Make b Arc - let _ = b.split_to(0); - b.truncate(7); - assert_eq!(b, s[..7]); - let b = b.freeze(); - assert_eq!(b, s[..7]); -} - -#[test] -fn freeze_after_split_off() { - let s = &b"abcdefgh"[..]; - let mut b = BytesMut::from(s); - let _ = b.split_off(7); - assert_eq!(b, s[..7]); - let b = b.freeze(); - assert_eq!(b, s[..7]); -} - -#[test] -fn fns_defined_for_bytes_mut() { - let mut bytes = BytesMut::from(&b"hello world"[..]); - - let _ = bytes.as_ptr(); - let _ = bytes.as_mut_ptr(); - - // Iterator - let v: Vec<u8> = bytes.as_ref().iter().cloned().collect(); - assert_eq!(&v[..], bytes); -} - -#[test] -fn reserve_convert() { - // Vec -> Vec - let mut bytes = BytesMut::from(LONG); - bytes.reserve(64); - assert_eq!(bytes.capacity(), LONG.len() + 64); - - // Arc -> Vec - let mut bytes = BytesMut::from(LONG); - let a = bytes.split_to(30); - - bytes.reserve(128); - assert!(bytes.capacity() >= bytes.len() + 128); - - drop(a); -} - -#[test] -fn reserve_growth() { - let mut bytes = BytesMut::with_capacity(64); - bytes.put("hello world".as_bytes()); - let _ = bytes.split(); - - bytes.reserve(65); - assert_eq!(bytes.capacity(), 117); -} - -#[test] -fn reserve_allocates_at_least_original_capacity() { - let mut bytes = BytesMut::with_capacity(1024); - - for i in 0..1020 { - bytes.put_u8(i as u8); - } - - let _other = bytes.split(); - - bytes.reserve(16); - assert_eq!(bytes.capacity(), 1024); -} - -#[test] -#[cfg_attr(miri, ignore)] // Miri is too slow -fn reserve_max_original_capacity_value() { - const SIZE: usize = 128 * 1024; - - let mut bytes = BytesMut::with_capacity(SIZE); - - for _ in 0..SIZE { - bytes.put_u8(0u8); - } - - let _other = bytes.split(); - - bytes.reserve(16); - assert_eq!(bytes.capacity(), 64 * 1024); -} - -#[test] -fn reserve_vec_recycling() { - let mut bytes = BytesMut::with_capacity(16); - assert_eq!(bytes.capacity(), 16); - let addr = bytes.as_ptr() as usize; - bytes.put("0123456789012345".as_bytes()); - assert_eq!(bytes.as_ptr() as usize, addr); - bytes.advance(10); - assert_eq!(bytes.capacity(), 6); - bytes.reserve(8); - assert_eq!(bytes.capacity(), 16); - assert_eq!(bytes.as_ptr() as usize, addr); -} - -#[test] -fn reserve_in_arc_unique_does_not_overallocate() { - let mut bytes = BytesMut::with_capacity(1000); - let _ = bytes.split(); - - // now bytes is Arc and refcount == 1 - - assert_eq!(1000, bytes.capacity()); - bytes.reserve(2001); - assert_eq!(2001, bytes.capacity()); -} - -#[test] -fn reserve_in_arc_unique_doubles() { - let mut bytes = BytesMut::with_capacity(1000); - let _ = bytes.split(); - - // now bytes is Arc and refcount == 1 - - assert_eq!(1000, bytes.capacity()); - bytes.reserve(1001); - assert_eq!(2000, bytes.capacity()); -} - -#[test] -fn reserve_in_arc_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); - let _copy = bytes.split(); - - // now bytes is Arc and refcount == 2 - - assert_eq!(1000, bytes.capacity()); - bytes.reserve(2001); - 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); - bytes.extend(LONG); - assert_eq!(*bytes, LONG[..]); -} - -#[test] -fn extend_from_slice_mut() { - for &i in &[3, 34] { - let mut bytes = BytesMut::new(); - bytes.extend_from_slice(&LONG[..i]); - bytes.extend_from_slice(&LONG[i..]); - assert_eq!(LONG[..], *bytes); - } -} - -#[test] -fn extend_mut_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); - let mut long_iter = LONG.iter(); - - // Use iter::from_fn since it doesn't know a size_hint - bytes.extend(std::iter::from_fn(|| long_iter.next())); - assert_eq!(*bytes, LONG[..]); -} - -#[test] -fn from_static() { - let mut a = Bytes::from_static(b"ab"); - let b = a.split_off(1); - - assert_eq!(a, b"a"[..]); - assert_eq!(b, b"b"[..]); -} - -#[test] -fn advance_static() { - let mut a = Bytes::from_static(b"hello world"); - a.advance(6); - assert_eq!(a, &b"world"[..]); -} - -#[test] -fn advance_vec() { - let mut a = Bytes::from(b"hello world boooo yah world zomg wat wat".to_vec()); - a.advance(16); - assert_eq!(a, b"o yah world zomg wat wat"[..]); - - a.advance(4); - assert_eq!(a, b"h world zomg wat wat"[..]); - - a.advance(6); - assert_eq!(a, b"d zomg wat wat"[..]); -} - -#[test] -fn advance_bytes_mut() { - let mut a = BytesMut::from("hello world boooo yah world zomg wat wat"); - a.advance(16); - assert_eq!(a, b"o yah world zomg wat wat"[..]); - - a.advance(4); - assert_eq!(a, b"h world zomg wat wat"[..]); - - // Reserve some space. - a.reserve(1024); - assert_eq!(a, b"h world zomg wat wat"[..]); - - a.advance(6); - assert_eq!(a, b"d zomg wat wat"[..]); -} - -// 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() { - let mut a = BytesMut::from("hello world"); - a.advance(20); -} - -#[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"))] -#[cfg(not(target_family = "wasm"))] // wasm without experimental threads proposal doesn't support threads -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 }; - - for i in 0..ITERS { - let data = [i as u8; 256]; - let buf = Arc::new(Bytes::copy_from_slice(&data[..])); - - let barrier = Arc::new(Barrier::new(THREADS)); - let mut joins = Vec::with_capacity(THREADS); - - for _ in 0..THREADS { - let c = barrier.clone(); - let buf = buf.clone(); - - joins.push(thread::spawn(move || { - c.wait(); - let buf: Bytes = (*buf).clone(); - drop(buf); - })); - } - - for th in joins { - th.join().unwrap(); - } - - assert_eq!(*buf, data[..]); - } -} - -#[test] -fn partial_eq_bytesmut() { - let bytes = Bytes::from(&b"The quick red fox"[..]); - let bytesmut = BytesMut::from(&b"The quick red fox"[..]); - assert!(bytes == bytesmut); - assert!(bytesmut == bytes); - let bytes2 = Bytes::from(&b"Jumped over the lazy brown dog"[..]); - assert!(bytes2 != bytesmut); - assert!(bytesmut != bytes2); -} - -#[test] -fn bytes_mut_unsplit_basic() { - let mut buf = BytesMut::with_capacity(64); - buf.extend_from_slice(b"aaabbbcccddd"); - - let splitted = buf.split_off(6); - assert_eq!(b"aaabbb", &buf[..]); - assert_eq!(b"cccddd", &splitted[..]); - - buf.unsplit(splitted); - assert_eq!(b"aaabbbcccddd", &buf[..]); -} - -#[test] -fn bytes_mut_unsplit_empty_other() { - let mut buf = BytesMut::with_capacity(64); - buf.extend_from_slice(b"aaabbbcccddd"); - - // empty other - let other = BytesMut::new(); - - buf.unsplit(other); - assert_eq!(b"aaabbbcccddd", &buf[..]); -} - -#[test] -fn bytes_mut_unsplit_empty_self() { - // empty self - let mut buf = BytesMut::new(); - - let mut other = BytesMut::with_capacity(64); - other.extend_from_slice(b"aaabbbcccddd"); - - buf.unsplit(other); - assert_eq!(b"aaabbbcccddd", &buf[..]); -} - -#[test] -fn bytes_mut_unsplit_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() { - let mut buf = BytesMut::with_capacity(64); - buf.extend_from_slice(b"aaaabbbbeeee"); - - let _ = buf.split_off(8); //arc - - let mut buf2 = BytesMut::with_capacity(64); - buf2.extend_from_slice(b"ccccddddeeee"); - - let _ = buf2.split_off(8); //arc - - buf.unsplit(buf2); - assert_eq!(b"aaaabbbbccccdddd", &buf[..]); -} - -#[test] -fn bytes_mut_unsplit_arc_non_contiguous() { - let mut buf = BytesMut::with_capacity(64); - buf.extend_from_slice(b"aaaabbbbeeeeccccdddd"); - - let mut buf2 = buf.split_off(8); //arc - - let buf3 = buf2.split_off(4); //arc - - buf.unsplit(buf3); - assert_eq!(b"aaaabbbbccccdddd", &buf[..]); -} - -#[test] -fn bytes_mut_unsplit_two_split_offs() { - let mut buf = BytesMut::with_capacity(64); - buf.extend_from_slice(b"aaaabbbbccccdddd"); - - let mut buf2 = buf.split_off(8); //arc - let buf3 = buf2.split_off(4); //arc - - buf2.unsplit(buf3); - buf.unsplit(buf2); - assert_eq!(b"aaaabbbbccccdddd", &buf[..]); -} - -#[test] -fn from_iter_no_size_hint() { - use std::iter; - - let mut expect = vec![]; - - let actual: Bytes = iter::repeat(b'x') - .scan(100, |cnt, item| { - if *cnt >= 1 { - *cnt -= 1; - expect.push(item); - Some(item) - } else { - None - } - }) - .collect(); - - assert_eq!(&actual[..], &expect[..]); -} - -fn test_slice_ref(bytes: &Bytes, start: usize, end: usize, expected: &[u8]) { - let slice = &(bytes.as_ref()[start..end]); - let sub = bytes.slice_ref(slice); - assert_eq!(&sub[..], expected); -} - -#[test] -fn slice_ref_works() { - let bytes = Bytes::from(&b"012345678"[..]); - - test_slice_ref(&bytes, 0, 0, b""); - test_slice_ref(&bytes, 0, 3, b"012"); - test_slice_ref(&bytes, 2, 6, b"2345"); - test_slice_ref(&bytes, 7, 9, b"78"); - test_slice_ref(&bytes, 9, 9, b""); -} - -#[test] -fn slice_ref_empty() { - let bytes = Bytes::from(&b""[..]); - let slice = &(bytes.as_ref()[0..0]); - - let sub = bytes.slice_ref(slice); - assert_eq!(&sub[..], b""); -} - -#[test] -fn slice_ref_empty_subslice() { - let bytes = Bytes::from(&b"abcde"[..]); - let subbytes = bytes.slice(0..0); - let slice = &subbytes[..]; - // The `slice` object is derived from the original `bytes` object - // so `slice_ref` should work. - assert_eq!(Bytes::new(), bytes.slice_ref(slice)); -} - -#[test] -#[should_panic] -fn slice_ref_catches_not_a_subset() { - let bytes = Bytes::from(&b"012345678"[..]); - let slice = &b"012345"[0..4]; - - bytes.slice_ref(slice); -} - -#[test] -fn slice_ref_not_an_empty_subset() { - let bytes = Bytes::from(&b"012345678"[..]); - let slice = &b""[0..0]; - - assert_eq!(Bytes::new(), bytes.slice_ref(slice)); -} - -#[test] -fn empty_slice_ref_not_an_empty_subset() { - let bytes = Bytes::new(); - let slice = &b"some other slice"[0..0]; - - assert_eq!(Bytes::new(), bytes.slice_ref(slice)); -} - -#[test] -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()); - - bytes.advance_mut(10); - - let next = bytes.chunk_mut().as_mut_ptr(); - assert_eq!(1024 - 10, bytes.chunk_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()); - } -} - -#[test] -fn bytes_buf_mut_reuse_when_fully_consumed() { - use bytes::{Buf, BytesMut}; - let mut buf = BytesMut::new(); - buf.reserve(8192); - buf.extend_from_slice(&[0u8; 100][..]); - - let p = &buf[0] as *const u8; - buf.advance(100); - - buf.reserve(8192); - buf.extend_from_slice(b" "); - - assert_eq!(&buf[0] as *const u8, p); -} - -#[test] -#[should_panic] -fn bytes_reserve_overflow() { - let mut bytes = BytesMut::with_capacity(1024); - bytes.put_slice(b"hello world"); - - bytes.reserve(usize::MAX); -} - -#[test] -fn bytes_with_capacity_but_empty() { - // See https://github.com/tokio-rs/bytes/issues/340 - 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[..]; -} - -#[derive(Clone)] -struct SharedAtomicCounter(Arc<AtomicUsize>); - -impl SharedAtomicCounter { - pub fn new() -> Self { - SharedAtomicCounter(Arc::new(AtomicUsize::new(0))) - } - - pub fn increment(&self) { - self.0.fetch_add(1, Ordering::AcqRel); - } - - pub fn get(&self) -> usize { - self.0.load(Ordering::Acquire) - } -} - -#[derive(Clone)] -struct OwnedTester<const L: usize> { - buf: [u8; L], - drop_count: SharedAtomicCounter, - pub panic_as_ref: bool, -} - -impl<const L: usize> OwnedTester<L> { - fn new(buf: [u8; L], drop_count: SharedAtomicCounter) -> Self { - Self { - buf, - drop_count, - panic_as_ref: false, - } - } -} - -impl<const L: usize> AsRef<[u8]> for OwnedTester<L> { - fn as_ref(&self) -> &[u8] { - if self.panic_as_ref { - panic!("test-triggered panic in `AsRef<[u8]> for OwnedTester`"); - } - self.buf.as_slice() - } -} - -impl<const L: usize> Drop for OwnedTester<L> { - fn drop(&mut self) { - self.drop_count.increment(); - } -} - -#[test] -fn owned_is_unique_always_false() { - let b1 = Bytes::from_owner([1, 2, 3, 4, 5, 6, 7]); - assert!(!b1.is_unique()); // even if ref_cnt == 1 - let b2 = b1.clone(); - assert!(!b1.is_unique()); - assert!(!b2.is_unique()); - drop(b1); - assert!(!b2.is_unique()); // even if ref_cnt == 1 -} - -#[test] -fn owned_buf_sharing() { - let buf = [1, 2, 3, 4, 5, 6, 7]; - let b1 = Bytes::from_owner(buf); - let b2 = b1.clone(); - assert_eq!(&buf[..], &b1[..]); - assert_eq!(&buf[..], &b2[..]); - assert_eq!(b1.as_ptr(), b2.as_ptr()); - assert_eq!(b1.len(), b2.len()); - assert_eq!(b1.len(), buf.len()); -} - -#[test] -fn owned_buf_slicing() { - let b1 = Bytes::from_owner(SHORT); - assert_eq!(SHORT, &b1[..]); - let b2 = b1.slice(1..(b1.len() - 1)); - assert_eq!(&SHORT[1..(SHORT.len() - 1)], b2); - assert_eq!(unsafe { SHORT.as_ptr().add(1) }, b2.as_ptr()); - assert_eq!(SHORT.len() - 2, b2.len()); -} - -#[test] -fn owned_dropped_exactly_once() { - let buf: [u8; 5] = [1, 2, 3, 4, 5]; - let drop_counter = SharedAtomicCounter::new(); - let owner = OwnedTester::new(buf, drop_counter.clone()); - let b1 = Bytes::from_owner(owner); - let b2 = b1.clone(); - assert_eq!(drop_counter.get(), 0); - drop(b1); - assert_eq!(drop_counter.get(), 0); - let b3 = b2.slice(1..b2.len() - 1); - drop(b2); - assert_eq!(drop_counter.get(), 0); - drop(b3); - assert_eq!(drop_counter.get(), 1); -} - -#[test] -fn owned_to_mut() { - let buf: [u8; 10] = [0, 1, 2, 3, 4, 5, 6, 7, 8, 9]; - let drop_counter = SharedAtomicCounter::new(); - let owner = OwnedTester::new(buf, drop_counter.clone()); - let b1 = Bytes::from_owner(owner); - - // Holding an owner will fail converting to a BytesMut, - // even when the bytes instance has a ref_cnt == 1. - let b1 = b1.try_into_mut().unwrap_err(); - - // That said, it's still possible, just not cheap. - let bm1: BytesMut = b1.into(); - let new_buf = &bm1[..]; - assert_eq!(new_buf, &buf[..]); - - // `.into::<BytesMut>()` has correctly dropped the owner - assert_eq!(drop_counter.get(), 1); -} - -#[test] -fn owned_to_vec() { - let buf: [u8; 10] = [0, 1, 2, 3, 4, 5, 6, 7, 8, 9]; - let drop_counter = SharedAtomicCounter::new(); - let owner = OwnedTester::new(buf, drop_counter.clone()); - let b1 = Bytes::from_owner(owner); - - let v1 = b1.to_vec(); - assert_eq!(&v1[..], &buf[..]); - assert_eq!(&v1[..], &b1[..]); - - drop(b1); - assert_eq!(drop_counter.get(), 1); -} - -#[test] -fn owned_into_vec() { - let drop_counter = SharedAtomicCounter::new(); - let buf: [u8; 10] = [0, 1, 2, 3, 4, 5, 6, 7, 8, 9]; - let owner = OwnedTester::new(buf, drop_counter.clone()); - let b1 = Bytes::from_owner(owner); - - let v1: Vec<u8> = b1.into(); - assert_eq!(&v1[..], &buf[..]); - // into() vec will copy out of the owner and drop it - assert_eq!(drop_counter.get(), 1); -} - -#[test] -#[cfg_attr(not(panic = "unwind"), ignore)] -fn owned_safe_drop_on_as_ref_panic() { - let buf: [u8; 10] = [0, 1, 2, 3, 4, 5, 6, 7, 8, 9]; - let drop_counter = SharedAtomicCounter::new(); - let mut owner = OwnedTester::new(buf, drop_counter.clone()); - owner.panic_as_ref = true; - - let result = panic::catch_unwind(AssertUnwindSafe(|| { - let _ = Bytes::from_owner(owner); - })); - - assert!(result.is_err()); - assert_eq!(drop_counter.get(), 1); -} diff --git a/vendor/bytes/tests/test_bytes_odd_alloc.rs b/vendor/bytes/tests/test_bytes_odd_alloc.rs deleted file mode 100644 index 4758dc2f..00000000 --- a/vendor/bytes/tests/test_bytes_odd_alloc.rs +++ /dev/null @@ -1,147 +0,0 @@ -//! 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}; - -#[global_allocator] -static ODD: Odd = Odd; - -struct Odd; - -unsafe impl GlobalAlloc for Odd { - unsafe fn alloc(&self, layout: Layout) -> *mut u8 { - if layout.align() == 1 && layout.size() > 0 { - // Allocate slightly bigger so that we can offset the pointer by 1 - let size = layout.size() + 1; - 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.offset(1) - } else { - ptr - } - } else { - System.alloc(layout) - } - } - - unsafe fn dealloc(&self, ptr: *mut u8, layout: Layout) { - if layout.align() == 1 && layout.size() > 0 { - let size = layout.size() + 1; - let new_layout = match Layout::from_size_align(size, 1) { - Ok(layout) => layout, - Err(_err) => std::process::abort(), - }; - System.dealloc(ptr.offset(-1), new_layout); - } else { - System.dealloc(ptr, layout); - } - } -} - -#[test] -fn sanity_check_odd_allocator() { - let vec = vec![33u8; 1024]; - let p = vec.as_ptr() as usize; - assert!(p & 0x1 == 0x1, "{:#b}", p); -} - -#[test] -fn test_bytes_from_vec_drop() { - let vec = vec![33u8; 1024]; - let _b = Bytes::from(vec); -} - -#[test] -fn test_bytes_clone_drop() { - let vec = vec![33u8; 1024]; - 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]); -} diff --git a/vendor/bytes/tests/test_bytes_vec_alloc.rs b/vendor/bytes/tests/test_bytes_vec_alloc.rs deleted file mode 100644 index 9c760171..00000000 --- a/vendor/bytes/tests/test_bytes_vec_alloc.rs +++ /dev/null @@ -1,146 +0,0 @@ -#![cfg(not(miri))] -use std::alloc::{GlobalAlloc, Layout, System}; -use std::ptr::null_mut; -use std::sync::atomic::{AtomicPtr, AtomicUsize, Ordering}; - -use bytes::{Buf, Bytes}; - -#[global_allocator] -static LEDGER: Ledger = Ledger::new(); - -const LEDGER_LENGTH: usize = 1024 * 1024; - -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); - return; - } - } - - panic!("Ledger ran out of space."); - } - - 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); - } -} - -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 - } - - unsafe fn dealloc(&self, ptr: *mut u8, layout: Layout) { - let orig_size = self.remove(ptr); - - if orig_size != layout.size() { - panic!( - "bad dealloc: alloc size was {}, dealloc size is {}", - orig_size, - layout.size() - ); - } else { - System.dealloc(ptr, layout); - } - } -} - -#[test] -fn test_bytes_advance() { - let mut bytes = Bytes::from(vec![10, 20, 30]); - bytes.advance(1); - drop(bytes); -} - -#[test] -fn test_bytes_truncate() { - let mut bytes = Bytes::from(vec![10, 20, 30]); - bytes.truncate(2); - drop(bytes); -} - -#[test] -fn test_bytes_truncate_and_advance() { - let mut bytes = Bytes::from(vec![10, 20, 30]); - bytes.truncate(2); - 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]); -} diff --git a/vendor/bytes/tests/test_chain.rs b/vendor/bytes/tests/test_chain.rs deleted file mode 100644 index cfda6b8d..00000000 --- a/vendor/bytes/tests/test_chain.rs +++ /dev/null @@ -1,177 +0,0 @@ -#![warn(rust_2018_idioms)] - -use bytes::{Buf, BufMut, Bytes}; -#[cfg(feature = "std")] -use std::io::IoSlice; - -#[test] -fn collect_two_bufs() { - let a = Bytes::from(&b"hello"[..]); - let b = Bytes::from(&b"world"[..]); - - let res = a.chain(b).copy_to_bytes(10); - assert_eq!(res, &b"helloworld"[..]); -} - -#[test] -fn writing_chained() { - let mut a = [0u8; 64]; - let mut b = [0u8; 64]; - - { - let mut buf = (&mut a[..]).chain_mut(&mut b[..]); - - for i in 0u8..128 { - buf.put_u8(i); - } - } - - for i in 0..64 { - let expect = i as u8; - assert_eq!(expect, a[i]); - assert_eq!(expect + 64, b[i]); - } -} - -#[test] -fn iterating_two_bufs() { - let a = Bytes::from(&b"hello"[..]); - let b = Bytes::from(&b"world"[..]); - - let res: Vec<u8> = a.chain(b).into_iter().collect(); - assert_eq!(res, &b"helloworld"[..]); -} - -#[cfg(feature = "std")] -#[test] -fn vectored_read() { - let a = Bytes::from(&b"hello"[..]); - let b = Bytes::from(&b"world"[..]); - - let mut buf = a.chain(b); - - { - let b1: &[u8] = &mut []; - let b2: &[u8] = &mut []; - let b3: &[u8] = &mut []; - let b4: &[u8] = &mut []; - let mut iovecs = [ - IoSlice::new(b1), - IoSlice::new(b2), - IoSlice::new(b3), - IoSlice::new(b4), - ]; - - assert_eq!(2, buf.chunks_vectored(&mut iovecs)); - assert_eq!(iovecs[0][..], b"hello"[..]); - assert_eq!(iovecs[1][..], b"world"[..]); - assert_eq!(iovecs[2][..], b""[..]); - assert_eq!(iovecs[3][..], b""[..]); - } - - buf.advance(2); - - { - let b1: &[u8] = &mut []; - let b2: &[u8] = &mut []; - let b3: &[u8] = &mut []; - let b4: &[u8] = &mut []; - let mut iovecs = [ - IoSlice::new(b1), - IoSlice::new(b2), - IoSlice::new(b3), - IoSlice::new(b4), - ]; - - assert_eq!(2, buf.chunks_vectored(&mut iovecs)); - assert_eq!(iovecs[0][..], b"llo"[..]); - assert_eq!(iovecs[1][..], b"world"[..]); - assert_eq!(iovecs[2][..], b""[..]); - assert_eq!(iovecs[3][..], b""[..]); - } - - buf.advance(3); - - { - let b1: &[u8] = &mut []; - let b2: &[u8] = &mut []; - let b3: &[u8] = &mut []; - let b4: &[u8] = &mut []; - let mut iovecs = [ - IoSlice::new(b1), - IoSlice::new(b2), - IoSlice::new(b3), - IoSlice::new(b4), - ]; - - assert_eq!(1, buf.chunks_vectored(&mut iovecs)); - assert_eq!(iovecs[0][..], b"world"[..]); - assert_eq!(iovecs[1][..], b""[..]); - assert_eq!(iovecs[2][..], b""[..]); - assert_eq!(iovecs[3][..], b""[..]); - } - - buf.advance(3); - - { - let b1: &[u8] = &mut []; - let b2: &[u8] = &mut []; - let b3: &[u8] = &mut []; - let b4: &[u8] = &mut []; - let mut iovecs = [ - IoSlice::new(b1), - IoSlice::new(b2), - IoSlice::new(b3), - IoSlice::new(b4), - ]; - - assert_eq!(1, buf.chunks_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()); -} diff --git a/vendor/bytes/tests/test_debug.rs b/vendor/bytes/tests/test_debug.rs deleted file mode 100644 index 08d2f254..00000000 --- a/vendor/bytes/tests/test_debug.rs +++ /dev/null @@ -1,35 +0,0 @@ -#![warn(rust_2018_idioms)] - -use bytes::Bytes; - -#[test] -fn fmt() { - let vec: Vec<_> = (0..0x100).map(|b| b as u8).collect(); - - let expected = "b\"\ - \\0\\x01\\x02\\x03\\x04\\x05\\x06\\x07\ - \\x08\\t\\n\\x0b\\x0c\\r\\x0e\\x0f\ - \\x10\\x11\\x12\\x13\\x14\\x15\\x16\\x17\ - \\x18\\x19\\x1a\\x1b\\x1c\\x1d\\x1e\\x1f\ - \x20!\\\"#$%&'()*+,-./0123456789:;<=>?\ - @ABCDEFGHIJKLMNOPQRSTUVWXYZ[\\\\]^_\ - `abcdefghijklmnopqrstuvwxyz{|}~\\x7f\ - \\x80\\x81\\x82\\x83\\x84\\x85\\x86\\x87\ - \\x88\\x89\\x8a\\x8b\\x8c\\x8d\\x8e\\x8f\ - \\x90\\x91\\x92\\x93\\x94\\x95\\x96\\x97\ - \\x98\\x99\\x9a\\x9b\\x9c\\x9d\\x9e\\x9f\ - \\xa0\\xa1\\xa2\\xa3\\xa4\\xa5\\xa6\\xa7\ - \\xa8\\xa9\\xaa\\xab\\xac\\xad\\xae\\xaf\ - \\xb0\\xb1\\xb2\\xb3\\xb4\\xb5\\xb6\\xb7\ - \\xb8\\xb9\\xba\\xbb\\xbc\\xbd\\xbe\\xbf\ - \\xc0\\xc1\\xc2\\xc3\\xc4\\xc5\\xc6\\xc7\ - \\xc8\\xc9\\xca\\xcb\\xcc\\xcd\\xce\\xcf\ - \\xd0\\xd1\\xd2\\xd3\\xd4\\xd5\\xd6\\xd7\ - \\xd8\\xd9\\xda\\xdb\\xdc\\xdd\\xde\\xdf\ - \\xe0\\xe1\\xe2\\xe3\\xe4\\xe5\\xe6\\xe7\ - \\xe8\\xe9\\xea\\xeb\\xec\\xed\\xee\\xef\ - \\xf0\\xf1\\xf2\\xf3\\xf4\\xf5\\xf6\\xf7\ - \\xf8\\xf9\\xfa\\xfb\\xfc\\xfd\\xfe\\xff\""; - - assert_eq!(expected, format!("{:?}", Bytes::from(vec))); -} diff --git a/vendor/bytes/tests/test_iter.rs b/vendor/bytes/tests/test_iter.rs deleted file mode 100644 index bad90186..00000000 --- a/vendor/bytes/tests/test_iter.rs +++ /dev/null @@ -1,21 +0,0 @@ -#![warn(rust_2018_idioms)] - -use bytes::{buf::IntoIter, Bytes}; - -#[test] -fn iter_len() { - let buf = Bytes::from_static(b"hello world"); - let iter = IntoIter::new(buf); - - assert_eq!(iter.size_hint(), (11, Some(11))); - assert_eq!(iter.len(), 11); -} - -#[test] -fn empty_iter_len() { - let buf = Bytes::new(); - let iter = IntoIter::new(buf); - - assert_eq!(iter.size_hint(), (0, Some(0))); - assert_eq!(iter.len(), 0); -} diff --git a/vendor/bytes/tests/test_reader.rs b/vendor/bytes/tests/test_reader.rs deleted file mode 100644 index 897aff64..00000000 --- a/vendor/bytes/tests/test_reader.rs +++ /dev/null @@ -1,29 +0,0 @@ -#![warn(rust_2018_idioms)] -#![cfg(feature = "std")] - -use std::io::{BufRead, Read}; - -use bytes::Buf; - -#[test] -fn read() { - let buf1 = &b"hello "[..]; - let buf2 = &b"world"[..]; - let buf = Buf::chain(buf1, buf2); // Disambiguate with Read::chain - let mut buffer = Vec::new(); - buf.reader().read_to_end(&mut buffer).unwrap(); - assert_eq!(b"hello world", &buffer[..]); -} - -#[test] -fn buf_read() { - let buf1 = &b"hell"[..]; - let buf2 = &b"o\nworld"[..]; - let mut reader = Buf::chain(buf1, buf2).reader(); - let mut line = String::new(); - reader.read_line(&mut line).unwrap(); - assert_eq!("hello\n", &line); - line.clear(); - reader.read_line(&mut line).unwrap(); - assert_eq!("world", &line); -} diff --git a/vendor/bytes/tests/test_serde.rs b/vendor/bytes/tests/test_serde.rs deleted file mode 100644 index cf4aeffa..00000000 --- a/vendor/bytes/tests/test_serde.rs +++ /dev/null @@ -1,20 +0,0 @@ -#![cfg(feature = "serde")] -#![warn(rust_2018_idioms)] - -use serde_test::{assert_tokens, Token}; - -#[test] -fn test_ser_de_empty() { - let b = bytes::Bytes::new(); - assert_tokens(&b, &[Token::Bytes(b"")]); - let b = bytes::BytesMut::with_capacity(0); - assert_tokens(&b, &[Token::Bytes(b"")]); -} - -#[test] -fn test_ser_de() { - let b = bytes::Bytes::from(&b"bytes"[..]); - assert_tokens(&b, &[Token::Bytes(b"bytes")]); - let b = bytes::BytesMut::from(&b"bytes"[..]); - assert_tokens(&b, &[Token::Bytes(b"bytes")]); -} diff --git a/vendor/bytes/tests/test_take.rs b/vendor/bytes/tests/test_take.rs deleted file mode 100644 index 0c0159be..00000000 --- a/vendor/bytes/tests/test_take.rs +++ /dev/null @@ -1,84 +0,0 @@ -#![warn(rust_2018_idioms)] - -use bytes::buf::Buf; -use bytes::Bytes; - -#[test] -fn long_take() { - // Tests that get a take with a size greater than the buffer length will not - // overrun the buffer. Regression test for #138. - let buf = b"hello world".take(100); - assert_eq!(11, buf.remaining()); - assert_eq!(b"hello world", buf.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); -} - -#[cfg(feature = "std")] -#[test] -fn take_chunks_vectored() { - fn chain() -> impl Buf { - Bytes::from([1, 2, 3].to_vec()).chain(Bytes::from([4, 5, 6].to_vec())) - } - - { - let mut dst = [std::io::IoSlice::new(&[]); 2]; - let take = chain().take(0); - assert_eq!(take.chunks_vectored(&mut dst), 0); - } - - { - let mut dst = [std::io::IoSlice::new(&[]); 2]; - let take = chain().take(1); - assert_eq!(take.chunks_vectored(&mut dst), 1); - assert_eq!(&*dst[0], &[1]); - } - - { - let mut dst = [std::io::IoSlice::new(&[]); 2]; - let take = chain().take(3); - assert_eq!(take.chunks_vectored(&mut dst), 1); - assert_eq!(&*dst[0], &[1, 2, 3]); - } - - { - let mut dst = [std::io::IoSlice::new(&[]); 2]; - let take = chain().take(4); - assert_eq!(take.chunks_vectored(&mut dst), 2); - assert_eq!(&*dst[0], &[1, 2, 3]); - assert_eq!(&*dst[1], &[4]); - } - - { - let mut dst = [std::io::IoSlice::new(&[]); 2]; - let take = chain().take(6); - assert_eq!(take.chunks_vectored(&mut dst), 2); - assert_eq!(&*dst[0], &[1, 2, 3]); - assert_eq!(&*dst[1], &[4, 5, 6]); - } - - { - let mut dst = [std::io::IoSlice::new(&[]); 2]; - let take = chain().take(7); - assert_eq!(take.chunks_vectored(&mut dst), 2); - assert_eq!(&*dst[0], &[1, 2, 3]); - assert_eq!(&*dst[1], &[4, 5, 6]); - } -} |