Struct Vec 

pub struct Vec<T> { /* private fields */ }

A concurrent, append-only vector.

See the crate documentation for details.

Notes

The bucket array is stored inline, meaning that the Vec<T> type is quite large on the stack. It is expected that you store it behind an Arc or similar.

Implementations

impl<T> Vec<T>

pub const fn new() -> Vec<T>

Constructs a new, empty Vec<T>.

Examples

let vec: boxcar::Vec<i32> = boxcar::Vec::new();

pub fn with_capacity(capacity: usize) -> Vec<T>

Constructs a new, empty Vec<T> with the specified capacity.

The vector will be able to hold at least capacity elements without reallocating.

Examples

let vec = boxcar::Vec::with_capacity(10);

for i in 0..10 {
    // Will not allocate.
    vec.push(i);
}

// May allocate.
vec.push(11);

pub fn reserve(&self, additional: usize)

Reserves capacity for at least additional more elements to be inserted in the given Vec<T>. The collection may reserve more space to avoid frequent reallocations.

Does nothing if capacity is already sufficient.

Examples

let vec = boxcar::Vec::new();
vec.reserve(10);

for i in 0..10 {
    // Will not allocate.
    vec.push(i);
}

// May allocate.
vec.push(11);

pub fn push(&self, value: T) -> usize

Appends an element to the back of the vector, returning the index it was inserted into.

Examples

let vec = boxcar::vec![1, 2];
assert_eq!(vec.push(3), 2);
assert_eq!(vec, [1, 2, 3]);

pub fn push_with<F>(&self, f: F) -> usize

where F: FnOnce(usize) -> T,

Appends the element returned from the closure f to the back of the vector at the index supplied to the closure.

Returns the index that the element was inserted into.

Examples

let vec = boxcar::vec![0, 1];
vec.push_with(|index| index);
assert_eq!(vec, [0, 1, 2]);

pub fn count(&self) -> usize

Returns the number of elements in the vector.

Note that due to concurrent writes, it is not guaranteed that all elements 0..vec.count() are initialized.

Examples

let vec = boxcar::Vec::new();
assert_eq!(vec.count(), 0);
vec.push(1);
vec.push(2);
assert_eq!(vec.count(), 2);

pub fn is_empty(&self) -> bool

Returns true if the vector contains no elements.

Examples

let vec = boxcar::Vec::new();
assert!(vec.is_empty());

vec.push(1);
assert!(!vec.is_empty());

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

Returns a reference to the element at the given index.

Examples

let vec = boxcar::vec![10, 40, 30];
assert_eq!(Some(&40), vec.get(1));
assert_eq!(None, vec.get(3));

pub fn get_mut(&mut self, index: usize) -> Option<&mut T>

Returns a mutable reference to the element at the given index.

Examples

let mut vec = boxcar::vec![10, 40, 30];
assert_eq!(Some(&mut 40), vec.get_mut(1));
assert_eq!(None, vec.get_mut(3));

pub unsafe fn get_unchecked(&self, index: usize) -> &T

Returns a reference to an element, without doing bounds checking or verifying that the element is fully initialized.

For a safe alternative see get.

Safety

Calling this method with an out-of-bounds index, or for an element that is being concurrently initialized is undefined behavior, even if the resulting reference is not used.

Examples

let vec = boxcar::vec![1, 2, 4];

unsafe {
    assert_eq!(vec.get_unchecked(1), &2);
}

pub unsafe fn get_unchecked_mut(&mut self, index: usize) -> &mut T

Returns a mutable reference to an element, without doing bounds checking or verifying that the element is fully initialized.

For a safe alternative see get.

Safety

Calling this method with an out-of-bounds index is undefined behavior, even if the resulting reference is not used.

Examples

let mut vec = boxcar::vec![1, 2, 4];

unsafe {
    assert_eq!(vec.get_unchecked_mut(1), &mut 2);
}

pub fn iter(&self) -> Iter<'_, T>

Returns an iterator over the vector.

Values are yielded in the form (index, value). The vector may have in-progress concurrent writes that create gaps, so index may not be strictly sequential.

Examples

let vec = boxcar::vec![1, 2, 4];
let mut iterator = vec.iter();

assert_eq!(iterator.next(), Some((0, &1)));
assert_eq!(iterator.next(), Some((1, &2)));
assert_eq!(iterator.next(), Some((2, &4)));
assert_eq!(iterator.next(), None);

pub fn clear(&mut self)

Clears the vector, removing all values.

Note that this method has no effect on the allocated capacity of the vector.

Examples

let mut vec = boxcar::Vec::new();
vec.push(1);
vec.push(2);

vec.clear();
assert!(vec.is_empty());

vec.push(3); // Will not allocate.

Trait Implementations

impl<T: Clone> Clone for Vec<T>

fn clone(&self) -> Vec<T>

Returns a duplicate of the value.

fn clone_from(&mut self, source: &Self)

Performs copy-assignment from source.

impl<T: Debug> Debug for Vec<T>

fn fmt(&self, f: &mut Formatter<'_>) -> Result

Formats the value using the given formatter.

impl<T> Default for Vec<T>

fn default() -> Vec<T>

Returns the “default value” for a type.

impl<T> Extend<T> for Vec<T>

fn extend<I: IntoIterator<Item = T>>(&mut self, iter: I)

Extends a collection with the contents of an iterator.

fn extend_one(&mut self, item: A)

🔬This is a nightly-only experimental API. (extend_one)

Extends a collection with exactly one element.

fn extend_reserve(&mut self, additional: usize)

🔬This is a nightly-only experimental API. (extend_one)

Reserves capacity in a collection for the given number of additional elements.

impl<T> FromIterator<T> for Vec<T>

fn from_iter<I: IntoIterator<Item = T>>(iter: I) -> Self

Creates a value from an iterator.

impl<T> Index<usize> for Vec<T>

type Output = T

The returned type after indexing.

fn index(&self, index: usize) -> &Self::Output

Performs the indexing (container[index]) operation.

impl<'a, T> IntoIterator for &'a Vec<T>

type Item = (usize, &'a T)

The type of the elements being iterated over.

type IntoIter = Iter<'a, T>

Which kind of iterator are we turning this into?

fn into_iter(self) -> Self::IntoIter

Creates an iterator from a value.

impl<T> IntoIterator for Vec<T>

type Item = T

The type of the elements being iterated over.

type IntoIter = IntoIter<T>

Which kind of iterator are we turning this into?

fn into_iter(self) -> Self::IntoIter

Creates an iterator from a value.

impl<A, T> PartialEq<A> for Vec<T>

where A: AsRef<[T]>, T: PartialEq,

fn eq(&self, other: &A) -> bool

Tests for self and other values to be equal, and is used by ==.

fn ne(&self, other: &Rhs) -> bool

Tests for !=. The default implementation is almost always sufficient, and should not be overridden without very good reason.

impl<T: PartialEq> PartialEq for Vec<T>

fn eq(&self, other: &Self) -> bool

Tests for self and other values to be equal, and is used by ==.

fn ne(&self, other: &Rhs) -> bool

Tests for !=. The default implementation is almost always sufficient, and should not be overridden without very good reason.

impl<T: Eq> Eq for Vec<T>