Struct elsa::sync::FrozenVec

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

Append-only threadsafe version of std::vec::Vec where insertion does not require mutable access

Implementations

impl<T> FrozenVec<T>

pub fn len(&self) -> usize

Returns the number of elements in the vector.

pub fn is_empty(&self) -> bool

Returns true if the vector contains no elements.

impl<T: StableDeref> FrozenVec<T>

pub fn new() -> Self

pub fn push(&self, val: T)

pub fn push_get(&self, val: T) -> &T::Target

Push, immediately getting a reference to the element

pub fn push_get_index(&self, val: T) -> usize

Push, immediately getting a an index of the element

Index can then be used with the get method

Examples

use elsa::sync::FrozenVec;

let map = FrozenVec::new();
let idx = map.push_get_index(String::from("a"));
assert_eq!(map.get(idx), Some("a"));
assert_eq!(idx, 0);
assert_eq!(map.push_get_index(String::from("b")), 1);

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

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

Returns an iterator over the vector.

impl<T> FrozenVec<T>

pub fn into_vec(self) -> Vec<T>

Returns the internal vector backing this structure

Examples

use elsa::sync::FrozenVec;

let map = FrozenVec::new();
map.push("a");
map.push("b");
let tuple_vec = map.into_vec();

assert_eq!(tuple_vec, vec!["a", "b"]);

Trait Implementations

impl<T> AsMut<Vec<T>> for FrozenVec<T>

fn as_mut(&mut self) -> &mut Vec<T>

Get mutable access to the underlying vector.

This is safe, as it requires a &mut self, ensuring nothing is using the ‘frozen’ contents.

impl<T: Clone> Clone for FrozenVec<T>

fn clone(&self) -> Self

Returns a copy of the value.

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

Performs copy-assignment from source.

impl<T: Debug> Debug for FrozenVec<T>

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

Formats the value using the given formatter.

impl<T> Default for FrozenVec<T>

fn default() -> Self

Returns the “default value” for a type.

impl<T> From<Vec<T>> for FrozenVec<T>

fn from(vec: Vec<T>) -> Self

Converts to this type from the input type.

impl<'a, T: StableDeref> IntoIterator for &'a FrozenVec<T>

type Item = &'a <T as Deref>::Target

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) -> Iter<'a, T>

Creates an iterator from a value.

impl<T: PartialEq> PartialEq for FrozenVec<T>

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

This method tests for self and other values to be equal, and is used by ==.

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

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