Messages in this thread | | | Date | Mon, 14 Nov 2022 14:35:01 +0000 | From | Gary Guo <> | Subject | Re: [PATCH v1 13/28] rust: alloc: add `Vec::try_with_capacity{,_in}()` constructors |
| |
On Thu, 10 Nov 2022 17:41:25 +0100 Miguel Ojeda <ojeda@kernel.org> wrote:
> Add `Vec::try_with_capacity()` and `Vec::try_with_capacity_in()` as > the fallible versions of `Vec::with_capacity()` and > `Vec::with_capacity_in()`, respectively. > > The implementations follow the originals and use the previously > added `RawVec::try_with_capacity_in()`. > > In turn, `Vec::try_with_capacity()` will be used to implement > the `CString` type (which wraps a `Vec<u8>`) in a later patch. > > Signed-off-by: Miguel Ojeda <ojeda@kernel.org>
Reviewed-by: Gary Guo <gary@garyguo.net>
> --- > rust/alloc/raw_vec.rs | 1 - > rust/alloc/vec/mod.rs | 89 +++++++++++++++++++++++++++++++++++++++++++ > 2 files changed, 89 insertions(+), 1 deletion(-) > > diff --git a/rust/alloc/raw_vec.rs b/rust/alloc/raw_vec.rs > index c342f3843972..eb77db5def55 100644 > --- a/rust/alloc/raw_vec.rs > +++ b/rust/alloc/raw_vec.rs > @@ -135,7 +135,6 @@ impl<T, A: Allocator> RawVec<T, A> { > > /// Like `try_with_capacity`, but parameterized over the choice of > /// allocator for the returned `RawVec`. > - #[allow(dead_code)] > #[inline] > pub fn try_with_capacity_in(capacity: usize, alloc: A) -> Result<Self, TryReserveError> { > Self::try_allocate_in(capacity, AllocInit::Uninitialized, alloc) > diff --git a/rust/alloc/vec/mod.rs b/rust/alloc/vec/mod.rs > index 540787804cc2..8ac6c1e3b2a8 100644 > --- a/rust/alloc/vec/mod.rs > +++ b/rust/alloc/vec/mod.rs > @@ -472,6 +472,48 @@ impl<T> Vec<T> { > Self::with_capacity_in(capacity, Global) > } > > + /// Tries to construct a new, empty `Vec<T>` with the specified capacity. > + /// > + /// The vector will be able to hold exactly `capacity` elements without > + /// reallocating. If `capacity` is 0, the vector will not allocate. > + /// > + /// It is important to note that although the returned vector has the > + /// *capacity* specified, the vector will have a zero *length*. For an > + /// explanation of the difference between length and capacity, see > + /// *[Capacity and reallocation]*. > + /// > + /// [Capacity and reallocation]: #capacity-and-reallocation > + /// > + /// # Examples > + /// > + /// ``` > + /// let mut vec = Vec::try_with_capacity(10).unwrap(); > + /// > + /// // The vector contains no items, even though it has capacity for more > + /// assert_eq!(vec.len(), 0); > + /// assert_eq!(vec.capacity(), 10); > + /// > + /// // These are all done without reallocating... > + /// for i in 0..10 { > + /// vec.push(i); > + /// } > + /// assert_eq!(vec.len(), 10); > + /// assert_eq!(vec.capacity(), 10); > + /// > + /// // ...but this may make the vector reallocate > + /// vec.push(11); > + /// assert_eq!(vec.len(), 11); > + /// assert!(vec.capacity() >= 11); > + /// > + /// let mut result = Vec::try_with_capacity(usize::MAX); > + /// assert!(result.is_err()); > + /// ``` > + #[inline] > + #[stable(feature = "kernel", since = "1.0.0")] > + pub fn try_with_capacity(capacity: usize) -> Result<Self, TryReserveError> { > + Self::try_with_capacity_in(capacity, Global) > + } > + > /// Creates a `Vec<T>` directly from the raw components of another vector. > /// > /// # Safety > @@ -617,6 +659,53 @@ impl<T, A: Allocator> Vec<T, A> { > Vec { buf: RawVec::with_capacity_in(capacity, alloc), len: 0 } > } > > + /// Tries to construct a new, empty `Vec<T, A>` with the specified capacity > + /// with the provided allocator. > + /// > + /// The vector will be able to hold exactly `capacity` elements without > + /// reallocating. If `capacity` is 0, the vector will not allocate. > + /// > + /// It is important to note that although the returned vector has the > + /// *capacity* specified, the vector will have a zero *length*. For an > + /// explanation of the difference between length and capacity, see > + /// *[Capacity and reallocation]*. > + /// > + /// [Capacity and reallocation]: #capacity-and-reallocation > + /// > + /// # Examples > + /// > + /// ``` > + /// #![feature(allocator_api)] > + /// > + /// use std::alloc::System; > + /// > + /// let mut vec = Vec::try_with_capacity_in(10, System).unwrap(); > + /// > + /// // The vector contains no items, even though it has capacity for more > + /// assert_eq!(vec.len(), 0); > + /// assert_eq!(vec.capacity(), 10); > + /// > + /// // These are all done without reallocating... > + /// for i in 0..10 { > + /// vec.push(i); > + /// } > + /// assert_eq!(vec.len(), 10); > + /// assert_eq!(vec.capacity(), 10); > + /// > + /// // ...but this may make the vector reallocate > + /// vec.push(11); > + /// assert_eq!(vec.len(), 11); > + /// assert!(vec.capacity() >= 11); > + /// > + /// let mut result = Vec::try_with_capacity_in(usize::MAX, System); > + /// assert!(result.is_err()); > + /// ``` > + #[inline] > + #[stable(feature = "kernel", since = "1.0.0")] > + pub fn try_with_capacity_in(capacity: usize, alloc: A) -> Result<Self, TryReserveError> { > + Ok(Vec { buf: RawVec::try_with_capacity_in(capacity, alloc)?, len: 0 }) > + } > + > /// Creates a `Vec<T, A>` directly from the raw components of another vector. > /// > /// # Safety
| |