Commit feadd062 authored by Miguel Ojeda's avatar Miguel Ojeda
Browse files

rust: alloc: add `Vec::try_with_capacity{,_in}()` constructors 



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.

Reviewed-by: default avatarGary Guo <gary@garyguo.net>
Signed-off-by: default avatarMiguel Ojeda <ojeda@kernel.org>
parent 51d3a25a

rust/alloc/raw_vec.rs

+0 −1
Original line number Diff line number Diff line
@@ -135,7 +135,6 @@ pub fn with_capacity_in(capacity: usize, alloc: A) -> Self { 


    /// 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)

rust/alloc/vec/mod.rs

+89 −0
Original line number Diff line number Diff line
@@ -472,6 +472,48 @@ pub fn with_capacity(capacity: usize) -> Self { 
        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 @@ pub fn with_capacity_in(capacity: usize, alloc: A) -> Self { 
        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