Struct starlark_map::vec2::Vec2

pub struct Vec2<A, B> { /* private fields */ }

Array of pairs (A, B), where A and B are stored separately. This reduces memory consumption when A and B have different alignments.

Implementations

impl<A, B> Vec2<A, B>

pub const fn new() -> Vec2<A, B>

Empty vec.

pub fn with_capacity(cap: usize) -> Vec2<A, B>

New instance with given capacity.

pub fn len(&self) -> usize

Number of elements.

pub fn capacity(&self) -> usize

Capacity.

pub fn is_empty(&self) -> bool

Is empty.

pub fn reserve(&mut self, additional: usize)

Reserve capacity for additional elements.

pub fn push(&mut self, a: A, b: B)

Push an element.

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

Get an element reference by index.

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

Get an element reference by index skipping bounds check.

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

Get an element mutable reference by index.

pub fn remove(&mut self, index: usize) -> (A, B)

Remove an element by index.

This is an O(n) operation.

pub fn clear(&mut self)

Remove all elements.

pub fn pop(&mut self) -> Option<(A, B)>

Remove the last element.

pub fn first(&self) -> Option<(&A, &B)>

Get the first element reference.

pub fn last(&self) -> Option<(&A, &B)>

Get the last element reference.

pub fn shrink_to_fit(&mut self)

If capacity exceeds length, shrink capacity to length.

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

Iterate over the elements.

pub fn sort_by<F>(&mut self, compare: F)

where F: FnMut((&A, &B), (&A, &B)) -> Ordering,

Sort the elements using given comparator.

Trait Implementations

impl<A: Allocative, B: Allocative> Allocative for Vec2<A, B>

fn visit<'a, 'b: 'a>(&self, visitor: &'a mut Visitor<'b>)

impl<A: Clone, B: Clone> Clone for Vec2<A, B>

fn clone(&self) -> Vec2<A, B>

Returns a copy of the value.

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

Performs copy-assignment from source.

impl<A: Debug, B: Debug> Debug for Vec2<A, B>

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

Formats the value using the given formatter.

impl<A, B> Default for Vec2<A, B>

fn default() -> Vec2<A, B>

Returns the “default value” for a type.

impl<A, B> Drop for Vec2<A, B>

fn drop(&mut self)

Executes the destructor for this type.

impl<A: Hash, B: Hash> Hash for Vec2<A, B>

fn hash<H: Hasher>(&self, state: &mut H)

Feeds this value into the given Hasher.

fn hash_slice<H>(data: &[Self], state: &mut H)

where H: Hasher, Self: Sized,

Feeds a slice of this type into the given Hasher.

impl<'s, A, B> IntoIterator for &'s Vec2<A, B>

type Item = (&'s A, &'s B)

The type of the elements being iterated over.

type IntoIter = Iter<'s, A, B>

Which kind of iterator are we turning this into?

fn into_iter(self) -> Self::IntoIter

Creates an iterator from a value.

impl<A, B> IntoIterator for Vec2<A, B>

type Item = (A, B)

The type of the elements being iterated over.

type IntoIter = IntoIter<A, B>

Which kind of iterator are we turning this into?

fn into_iter(self) -> IntoIter<A, B>

Creates an iterator from a value.

impl<A: PartialEq, B: PartialEq> PartialEq for Vec2<A, B>

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.

impl<A: Eq, B: Eq> Eq for Vec2<A, B>

impl<A: Send, B: Send> Send for Vec2<A, B>

impl<A: Sync, B: Sync> Sync for Vec2<A, B>