| Age | Commit message (Collapse) | Author | Files | Lines |
|---|
|
<Arc<T>>::make_mut returns a &mut T, such an API is doable for Bytes too
and thus we should reserve Bytes::make_mut for that.
Furthermore, it would be helpful to use From<Bytes> as a trait bound
in some cases with other traits such as Hyper's body trait, where Hyper
gives you Bytes values.
Finally, making it impl From<Bytes> for BytesMut means the API is more
easily discoverable as it appears on both Bytes and BytesMut.
|
|
|
|
|
|
|
|
|
|
|
|
|
|
Follow up to https://github.com/tokio-rs/bytes/pull/689
* If `at == self.len()`, we already know `at <= self.len()`.
* If `at == 0`, we already know `at <= self.len()`.
|
|
* use checked_sub
* return when additional == 0
* move safe operation out of unsafe block
* use spare_capacity_mut instead of chunk_mut
We don't need to check capacity because it's already been reserved
above.
* Add safety comments
* refactor to use guard clauses
This would be better written with let-else, but we won't get that until
`MSRV >= 1.65.x`.
* use if-let instead of unwrap
* reduce scope of unsafe blocks
Co-authored-by: Alice Ryhl <aliceryhl@google.com>
---------
Co-authored-by: Alice Ryhl <aliceryhl@google.com>
|
|
|
|
Signed-off-by: tison <wander4096@gmail.com>
|
|
If `at == self.len()` then we already know `at <= self.len()`. If
`at == 0`, it can't be greater than `self.len()`.
|
|
A fundamental invariant of `reserve` is that it can extend capacity
while the stored data remains the same, even if it's moved to a new
allocation. As a result, `len` can never change during a call to
`reserve`.
|
|
|
|
|
|
|
|
Fixes #454.
|
|
CI is [failing][failure] due to unused_imports because Iterator is
already in the prelude. Removing it fixes things up.
[failure]: https://github.com/tokio-rs/bytes/actions/runs/8034858583/job/21946873895
|
|
* set len a little more concisely
* inline set_end
* remove kind assertions
* remove a duplicate assertion
* remove redundant assertion and min
* rename set_start to advance_unchecked
|
|
I can't see any reason that get_vec_pos needs a &mut self.
|
|
The second argument to `set_vec_pos` always contains the value of
`self.data`. Let's just use `self.data` and remove the second parameter
altogether.
|
|
We don't need the original capacity if the shared data is unique, so
let's not calculate it until after that check.
|
|
We're always subtracting here, and we already have a usize, so `sub`
seems like a more appropriate usage to me.
|
|
These seem to have been commented by accident in #298, and are still
passing.
|
|
Instead of re-declaring `vec`, we can just use a mut parameter.
|
|
|
|
|
|
|
|
|
|
Back in #362, an assertion was added to ensure that the alignment of
bytes::Shared is even so we can use the least significant bit as a flag.
bytes_mut::Shared uses the same technique but has no such assertion so
I've added one here.
|
|
I was a little confused about these calls using `Self::` instead of
`self.` here. Is there a reason to use the former instead of the latter?
|
|
This reworks `UninitSlice::as_uninit_slice_mut()` using equivalent
simpler logic.
|
|
Fixed a few broken links and converted a lot of them from the
html-link to intra-doc links.
|
|
Co-authored-by: Daniel Bauman <danielbauman@Daniels-MacBook-Pro.local>
|
|
|
|
|
|
|
|
tokio::io::ReadBuf uses names `new` and `uninit` for its constructors.
For consistency with that, rename recently introduced UninitSlice
constructors to match those names.
|
|
|
|
Introduce UninitSlice::from_slice and UninitSlice::from_uninit_slice
methods which safely create Uninit slice from provided slice of maybe
uninitialised or initialised memory.
In addition, add `From<&mut [T]>` implementations (for `T=u8` and
`T=MaybeUninit<u8>`) which do conversion from slice to UninitSlice.
Closes: #552
|
|
This function can be hot in applications that do a lot of encoding. Ideally would do the same for `<BytesMut as BufMut>::put_slice` and `<BytesMut as BufMut::put_u8`.
|
|
When we freeze a BytesMut, we turn it into a Vec, and then convert that
to a Bytes. Currently, this happen using Vec::into_boxed_slice, which
reallocates to a slice of the same length as the Vev if the length and
the capacity are not equal. This can pose a performance problem if the
Vec is large or if this happens many times in a loop.
Instead, let's compare the length and capacity, and if they're the same,
continue to handle this using into_boxed_slice. Otherwise, since we
have a type of vtable which can handle a separate capacity, the shared
vtable, let's turn our Vec into that kind of Bytes. While this does not
avoid allocation altogether, it performs a fixed size allocation and
avoids any need to memcpy.
|
|
|
|
Co-authored-by: Nicolae Mihalache <nicolae.mihalache@spaceapplications.com>
|
|
|
|
Fixes #549
|
|
|
|
|
|
|
|
Fixes calls to `reserve` when the underlying shared buffer was already
big enough to fit the requested capacity. Previously a new even larger
buffer was created anyways. This could eventually lead to an OOM
condition.
|
Anthony Ramine
Brad Dunbar
Émile Fugulin
Alice Ryhl
Paolo Barbolini
Paolo Barbolini
tison
Cyborus04
Luca Bruno
Gabriel Goller
DanielB
mxsm
Lucas Kent
Michal Nazarewicz
Paa Kojo Samanpa
brian m. carlson
0xc0001a2040
Nicolae Mihalache
Matthijs van Otterdijk
Sean Lynch
Yotam Ofek
Adam Chalmers
Matt Schulte
