Struct alot::unordered::Lots

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

A collection of T, organized by generational LotIds.

This data type allows storing data of any type and receiving a LotId that can later be used to look up the data.

This data type cannot hold more than 2^48 items, due how LotIds are allocated.

Generation Checks

A LotId contains 16 bits representing a lot’s generation. Each time a lot is updated, the lot’s generation is incremented (with wrapping).

The lot’s generation is checked when retrieving data using a LotId. If a generation mismatch is found, the data will not be returned.

While the chances of generation collision may be low, this is not a perfect check. Care should still be taken to ensure stale LotIds aren’t used when other ways of validating the data don’t exist.

Implementations

impl<T> Lots<T>

pub const fn new() -> Self

Returns a new, empty collection.

pub fn with_capacity(initial_capacity: usize) -> Self

Returns an empty collection that can hold initial_capacity values without reallocation.

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

Adds value to the collection, returning the value’s unique LotId.

pub fn clear(&mut self)

Removes all values from the collection.

pub fn get(&self, id: LotId) -> Option<&T>

Looks up a previously stored value by its LotId. If the value hasn’t been removed, a reference will be returned.

Note: It is possible, but unlikely, for a LotId that has been removed to be reused.

pub fn get_mut(&mut self, id: LotId) -> Option<&mut T>

Looks up a previously stored value by its LotId. If the value hasn’t been removed, a mutable reference will be returned.

Note: It is possible, but unlikely, for a LotId that has been removed to be reused.

pub fn remove(&mut self, id: LotId) -> Option<T>

Removes a previously stored value by its LotId. If the value is present, it will be removed and returned.

Note: It is possible, but unlikely, for a LotId that has been removed to be reused.

pub fn drain(&mut self) -> Drain<'_, T, DrainAll>

Returns an iterator that returns all the contained values in this collection as they’re removed from the collection.

Dropping the iterator will still result in the elements being removed.

pub fn drain_filter<Filter>(&mut self, filter: Filter) -> Drain<'_, T, Filter>

where Filter: FnMut(&mut T) -> bool,

Returns an iterator that invokes filter for each item in the collection. If filter returns true for that value, it will be removed and returned from the iterator. When false is returned, the value is kept in the collection.

Dropping the iterator will still result in the filtered elements being removed.

pub fn len(&self) -> usize

Returns the number of values contained in this collection.

pub fn is_empty(&self) -> bool

Returns true if this collection has no values.

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

Returns an iterator of references to all contained values.

pub fn iter_mut(&mut self) -> IterMut<'_, T>

Returns an iterator of exclusive references to all contained values.

pub fn entries(&self) -> EntryIter<'_, T>

Returns an Iterator<Item = (LotId, &T)> for all contained values.

Trait Implementations

impl<T: Clone> Clone for Lots<T>

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

Returns a copy of the value.

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

Performs copy-assignment from source.

impl<T> Debug for Lots<T>

where T: Debug,

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

Formats the value using the given formatter.

impl<T> Default for Lots<T>

fn default() -> Self

Returns the “default value” for a type.

impl<T> FromIterator<T> for Lots<T>

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

Creates a value from an iterator.

impl<T> Index<LotId> for Lots<T>

type Output = T

The returned type after indexing.

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

Performs the indexing (container[index]) operation.

impl<T> IndexMut<LotId> for Lots<T>

fn index_mut(&mut self, id: LotId) -> &mut Self::Output

Performs the mutable indexing (container[index]) operation.

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

type IntoIter = Iter<'a, T>

Which kind of iterator are we turning this into?

type Item = &'a T

The type of the elements being iterated over.

fn into_iter(self) -> Self::IntoIter

Creates an iterator from a value.

impl<'a, T> IntoIterator for &'a mut Lots<T>

type IntoIter = IterMut<'a, T>

Which kind of iterator are we turning this into?

type Item = &'a mut T

The type of the elements being iterated over.

fn into_iter(self) -> Self::IntoIter

Creates an iterator from a value.

impl<T> IntoIterator for Lots<T>

type IntoIter = IntoIter<T>

Which kind of iterator are we turning this into?

type Item = T

The type of the elements being iterated over.

fn into_iter(self) -> Self::IntoIter

Creates an iterator from a value.

impl<T> PartialEq for Lots<T>

where T: 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.

impl<T> Eq for Lots<T>

where T: Eq,