Struct elsa::vec::FrozenVec

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

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

Implementations

impl<T> FrozenVec<T>

pub fn new() -> Self

Constructs a new, empty vector.

Examples found in repository

examples/arena.rs (line 30)

    fn new() -> Arena<'arena> {
        Arena {
            things: FrozenVec::new(),
        }
    }

examples/mutable_arena.rs (line 31)

    fn new() -> Arena<'arena> {
        Arena {
            people: FrozenVec::new(),
        }
    }

impl<T> FrozenVec<T>

pub fn push(&self, val: T)

Appends an element to the back of the vector.

Examples found in repository

examples/arena.rs (line 40)

    fn add_thing(
        &'arena self,
        name: &'static str,
        friends: Vec<ThingRef<'arena>>,
    ) -> ThingRef<'arena> {
        let idx = self.things.len();
        self.things.push(Box::new(Thing { name, friends }));
        &self.things[idx]
    }

examples/mutable_arena.rs (lines 41-45)

    fn add_person(
        &'arena self,
        name: &'static str,
        follows: Vec<PersonRef<'arena>>,
    ) -> PersonRef<'arena> {
        let idx = self.people.len();
        self.people.push(Box::new(Person {
            name,
            follows: follows.into(),
            reverse_follows: Default::default(),
        }));
        let me = &self.people[idx];
        for friend in &me.follows {
            friend.reverse_follows.push(me)
        }
        me
    }

impl<T: StableDeref> FrozenVec<T>

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

Push, immediately getting a reference to the element

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

Returns a reference to an element.

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

Returns a reference to an element, without doing bounds checking.

Safety

index must be in bounds, i.e. it must be less than self.len()

impl<T: Copy> FrozenVec<T>

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

Returns a copy of an element.

impl<T> FrozenVec<T>

pub fn len(&self) -> usize

Returns the number of elements in the vector.

Examples found in repository

examples/arena.rs (line 39)

    fn add_thing(
        &'arena self,
        name: &'static str,
        friends: Vec<ThingRef<'arena>>,
    ) -> ThingRef<'arena> {
        let idx = self.things.len();
        self.things.push(Box::new(Thing { name, friends }));
        &self.things[idx]
    }

examples/mutable_arena.rs (line 40)

    fn add_person(
        &'arena self,
        name: &'static str,
        follows: Vec<PersonRef<'arena>>,
    ) -> PersonRef<'arena> {
        let idx = self.people.len();
        self.people.push(Box::new(Person {
            name,
            follows: follows.into(),
            reverse_follows: Default::default(),
        }));
        let me = &self.people[idx];
        for friend in &me.follows {
            friend.reverse_follows.push(me)
        }
        me
    }

pub fn is_empty(&self) -> bool

Returns true if the vector contains no elements.

impl<T: StableDeref> FrozenVec<T>

pub fn first(&self) -> Option<&T::Target>

Returns the first element of the vector, or None if empty.

pub fn last(&self) -> Option<&T::Target>

Returns the last element of the vector, or None if empty.

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

Returns an iterator over the vector.

impl<T: StableDeref> FrozenVec<T>

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

Converts the frozen vector into a plain vector.

impl<T: StableDeref> FrozenVec<T>

pub fn binary_search(&self, x: &T::Target) -> Result<usize, usize>

where T::Target: Ord,

Binary searches this sorted vector for a given element, analogous to slice::binary_search.

pub fn binary_search_by<'a, F>(&'a self, f: F) -> Result<usize, usize>

where F: FnMut(&'a T::Target) -> Ordering,

Binary searches this sorted vector with a comparator function, analogous to slice::binary_search_by.

pub fn binary_search_by_key<'a, B, F>( &'a self, b: &B, f: F ) -> Result<usize, usize>

where F: FnMut(&'a T::Target) -> B, B: Ord,

Binary searches this sorted vector with a key extraction function, analogous to slice::binary_search_by_key.

pub fn partition_point<P>(&self, pred: P) -> usize

where P: FnMut(&T::Target) -> bool,

Returns the index of the partition point according to the given predicate (the index of the first element of the second partition), analogous to slice::partition_point.

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> 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> FromIterator<A> for FrozenVec<A>

fn from_iter<T>(iter: T) -> Self

where T: IntoIterator<Item = A>,

Creates a value from an iterator.

impl<T: StableDeref> Index<usize> for FrozenVec<T>

type Output = <T as Deref>::Target

The returned type after indexing.

fn index(&self, idx: usize) -> &T::Target

Performs the indexing (container[index]) operation.

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: StableDeref + PartialEq> PartialEq for FrozenVec<T>

where T::Target: PartialEq,

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.