Struct std::collections::Vector

Growable heap-allocated array.

Example

use std::collections::Vector;

let vec = Vector::new::<i32>();
defer vec.free();

vec.push(1);
vec.push(2);
vec.push(3);

assert_eq!(vec.len(), 3);
assert_eq!(vec[0], 1);
assert_eq!(vec[1], 2);
assert_eq!(vec[2], 3);
Run this example

Methods

• fn new() -> Vector<T>

  source

  Create an empty vector

  This will not allocate until the first element is inserted.

• fn from_raw(data: &mut [T], length: usize) -> Vector<T>

  source

  Create a vector from a raw slice and a length.

  The slice must be allocated with alloc and its length must be greater than or equal to length.

• fn with_capacity(capacity: usize) -> Vector<T>

  source

  Create a vector that can hold up to capacity elements without reallocating.

• fn from_slice(slice: &[T]) -> Vector<T>

  source

  Create a vector from a slice, copying the elements.

  Example

  use std::collections::Vector;
  
  let vec = Vector::from_slice(&[1, 2, 3]);
  assert_eq!(vec.len(), 3);
  assert_eq!(vec[..], &[1, 2, 3]);
  Run this example

• fn from_iter<I>(iter: &mut I) -> Vector<T>

  I: Iterator<I, T>

  source

  Create a vector from an iterator.

  See also to_vector for a chainable version.

  Example

  use std::collections::Vector;
  
  let vec: Vector<i32> = Vector::from_iter(&(0..3));
  assert_eq!(vec.len(), 3);
  assert_eq!(vec[..], &[0, 1, 2]);
  Run this example

• fn reserve(self: &mut Vector<T>, additional: usize)

  source

  Reserve capacity for at least additional elements.

• fn extend_from_slice(self: &mut Vector<T>, value: &[T])

  source

  Extend the vector with the elements from a slice.

  Example

  use std::collections::Vector;
  
  let vec = Vector::new::<i32>();
  vec.extend_from_slice(&[1, 2, 3]);
  vec.extend_from_slice(&[4, 5, 6]);
  assert_eq!(vec.len(), 6);
  assert_eq!(vec[..], &[1, 2, 3, 4, 5, 6]);
  Run this example

• fn extend<I>(self: &mut Vector<T>, iter: &mut I)

  I: Iterator<I, T>

  source

  Extend the vector with the elements from an iterator.

• fn insert(self: &mut Vector<T>, index: usize, value: T)

  source

  Insert an element at the given index, shifting all elements after it.

  Example

  use std::collections::Vector;
  
  let vec = Vector::from_slice(&[0, 1, 2, 3, 4]);
  vec.insert(0, 100);
  vec.insert(4, 200);
  vec.insert(7, 300);
  assert_eq!(vec[..], &[100, 0, 1, 2, 200, 3, 4, 300]);
  Run this example

• fn get(self: &Vector<T>, index: usize) -> Option<T>

  source

  Get the element at the given index.

  If the index is out of bounds, it returns Option::none().

• fn as_slice(self: &Vector<T>) -> &[T]

  source

  Returns the contents of the object as a slice.

  See AsSlice for details.

• fn as_slice_mut(self: &mut Vector<T>) -> &mut [T]

  source

  Returns the contents of the object as a mutable slice.

  See AsSliceMut for details.

• fn push(self: &mut Vector<T>, value: T)

  source

  Push an element to the end of the vector.

• fn pop(self: &mut Vector<T>) -> Option<T>

  source

  Pop an element from the end of the vector.

  If the vector is empty, it returns Option::none().

• fn remove(self: &mut Vector<T>, index: usize) -> T

  source

  Remove an element at the given index, shifting all elements after it.

• fn len(self: &Vector<T>) -> usize

  source

  Return the length of the vector.

• fn capacity(self: &Vector<T>) -> usize

  source

  Return the size of the underlying buffer.

• fn spare_capacity(self: &mut Vector<T>) -> &mut [T]

  source

  Returns a region of memory "after the last element".

  This can be used to efficiently append elements to the vector. The memory may not be initialized.

• fn is_empty(self: &Vector<T>) -> bool

  source

  Returns true if the vector is empty, false otherwise.

• fn clear(self: &mut Vector<T>)

  source

  Clear the vector, removing all elements.

  Does not remove excess capacity, call shrink_to_fit afterwards, if this is desired.

• fn truncate(self: &mut Vector<T>, new_size: usize)

  source

  Truncate the vector, removing all but the first new_size elements.

  new_size should not be greater than the current capacity of the vector, but it may be greater than the current length of the vector. In this case the vector will grow to the specified capacity.

  vec.truncate(0) is equivalent to vec.clear().

• fn retain<F>(self: &mut Vector<T>, func: F)

  F: Fn(&T) -> bool

  source

  Removes the elements not mathing the given predicate.

  Does not remove excess capacity, call shrink_to_fit afterwards, if this is desired.

  Example

  let vec = (0..=10).to_vector();
  defer vec.free();
  
  vec.retain(|x: &i32| -> bool { *x % 2 == 0 });
  assert_eq!(vec[..], &[0, 2, 4, 6, 8, 10]);
  Run this example

• fn iter(self: &Vector<T>) -> SliceIterator<&T>

  source

  Returns an iterator over the elements of this iterable.

  See Iterable for details.

• fn iter_ref(self: &Vector<T>) -> SliceRefIterator<&T>

  source

  Returns an iterator over the pointers of the items of this iterable.

  See IterableRef for details.

• fn iter_mut(self: &mut Vector<T>) -> SliceRefIterator<&mut T>

  source

  Returns an iterator over mutable pointers to the elements of the collection.

  See IterableMut for details.

• fn borrow(self: &Vector<T>) -> &[T]

  source

  Returns a view to the object.

• fn borrow_mut(self: &mut Vector<T>) -> &mut [T]

  source

  Returns a mutable view to the object.

• fn shrink_to_fit(self: &mut Vector<T>)

  source

  Shrink the underlying buffer to the length of the vector.

• fn free(self: &mut Vector<T>)

  source

  Frees the memory backing the object.

• fn free_all(self: &mut Vector<T>)

  source

  Helper for collections that own heap-allocated objects. This is used to be able to do defer col.free_all() without much boilerplate.

  Example

  use std::collections::Vector;
  use std::string::StringBuf;
  use std::fmt::format;
  
  let v: Vector<StringBuf> = Vector::new();
  defer v.free_all();
  
  for i in 1..10 {
      v.push("{} + {} = {}".format!(i, i, i + i).unwrap());
  }
  Run this example

• fn move(self: &mut Vector<T>) -> Vector<T>

  source

  Creates a copy of the object, leaving an inert object behind.

  See Movable for details.

• fn clone(self: &Vector<T>) -> Vector<T>

  source

  Returns a copy of the object.