Implement methods in Vector for changing capacity (reserve and shrink variations)

PiperOrigin-RevId: 696960440
Change-Id: Icc1231cd2353419dacd4b62192163527a90afe43

Author: dvadym

support/cc_std/test/vector/test.rs

@@ -285,6 +285,67 @@ fn test_vector_reserve() {
     let mut v = vector::Vector::<i32>::new();
     v.reserve(10);
     expect_that!(v.capacity(), ge(10));
+    let current_capacity = v.capacity();
+    v.reserve(5); // 5 < 10, so it should do nothing.
+    expect_eq!(v.capacity(), current_capacity);
+}
+
+#[gtest]
+fn test_vector_reserve_exact() {
+    let mut v = vector::Vector::<usize>::new();
+    v.reserve_exact(10);
+    expect_that!(v.capacity(), ge(10));
+    let current_capacity = v.capacity();
+    // Add elements to the current capacity.
+    for i in v.len()..current_capacity {
+        v.push(i);
+    }
+    v.reserve_exact(5); // it ensures that the capacity for additional 5 elements.
+    expect_that!(v.capacity(), ge(current_capacity + 5));
+}
+
+#[gtest]
+fn test_vector_try_reserve() {
+    let mut v = vector::Vector::<i32>::new();
+    v.try_reserve(100).unwrap();
+    expect_that!(v.capacity(), ge(100));
+}
+
+#[gtest]
+fn test_vector_try_reserve_exact() {
+    let mut v = vector::Vector::<usize>::new();
+    v.try_reserve_exact(10).unwrap();
+    expect_that!(v.capacity(), ge(10));
+    let current_capacity = v.capacity();
+    // Add elements to the current capacity.
+    for i in v.len()..current_capacity {
+        v.push(i);
+    }
+    v.try_reserve_exact(5).unwrap(); // it ensures that the capacity for additional 5 elements.
+    expect_that!(v.capacity(), ge(current_capacity + 5));
+}
+
+#[gtest]
+fn test_shrink_to_fit() {
+    let mut v = vector::Vector::<i32>::new();
+    for i in 0..100 {
+        v.push(i);
+    }
+    v.clear(); // doesn't shrink the capacity.
+    v.shrink_to_fit();
+    expect_eq!(v.capacity(), 0);
+}
+
+#[gtest]
+fn test_shrink_to() {
+    let mut v = vector::Vector::<i32>::new();
+    for i in 0..100 {
+        v.push(i);
+    }
+    v.clear(); // doesn't shrink the capacity.
+    v.shrink_to(10);
+    expect_that!(v.capacity(), le(99));
+    expect_that!(v.capacity(), ge(10));
 }
 
 #[gtest]

support/cc_std/vector.rs

@@ -3,6 +3,7 @@
 // SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 #![feature(allocator_api)]
 #![feature(cfg_sanitize)]
+use std::collections::TryReserveError;
 #[cfg(sanitize = "address")]
 use std::ffi::c_void;
 use std::mem::ManuallyDrop;
@@ -161,10 +162,31 @@ impl<T: Unpin> Vector<T> {
         }
     }
 
+    // Methods for changing the capacity of the vector.
     pub fn reserve(&mut self, capacity: usize) {
         self.mutate_self_as_vec(|v| v.reserve(capacity));
     }
 
+    pub fn reserve_exact(&mut self, additional: usize) {
+        self.mutate_self_as_vec(|v| v.reserve_exact(additional));
+    }
+
+    pub fn try_reserve(&mut self, additional: usize) -> Result<(), TryReserveError> {
+        self.mutate_self_as_vec(|v| v.try_reserve(additional))
+    }
+
+    pub fn try_reserve_exact(&mut self, additional: usize) -> Result<(), TryReserveError> {
+        self.mutate_self_as_vec(|v| v.try_reserve_exact(additional))
+    }
+
+    pub fn shrink_to_fit(&mut self) {
+        self.mutate_self_as_vec(|v| v.shrink_to_fit());
+    }
+
+    pub fn shrink_to(&mut self, min_capacity: usize) {
+        self.mutate_self_as_vec(|v| v.shrink_to(min_capacity));
+    }
+
     pub fn with_capacity(capacity: usize) -> Vector<T> {
         let mut result = Vector::new();
         result.reserve(capacity);