Struct alot::ordered::OrderedLots

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

A collection of T values that maintains the order of elements.

This collection can be accessed by index (usize) or the LotId it is assigned upon insertion or pushing.

This collection has Vec-like performance except when removing elements by LotId, which is an O(n) operation.

Implementations

impl<T> OrderedLots<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 end of the collection, returning the value’s unique LotId.

pub fn pop(&mut self) -> Option<T>

Removes the last element of the collection, if one is present.

pub fn pop_entry(&mut self) -> Option<(LotId, T)>

Removes the last element of the collection, if one is present.

pub fn insert(&mut self, offset: usize, value: T) -> LotId

Inserts value at offset inside of the collection.

Panics

This funciton panics if offset is greater than the length of the collection.

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

Removes the value with the associated LotId, if found.

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

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

Removes the value at index, returning the LotId and value if found.

pub fn sort(&mut self)

where T: Ord,

Orders the elements in this collection leveraging the standard library’s sorting implementation. See slice::sort() for more information.

pub fn sort_by<F: Fn(&T, &T) -> Ordering>(&mut self, comparison: F)

Orders the elements in this collection leveraging the standard library’s sorting implementation. See slice::sort_by() for more information.

pub fn sort_by_key<K, F>(&mut self, f: F)

where F: FnMut(&T) -> K, K: Ord,

Orders the elements in this collection leveraging the standard library’s sorting implementation. See slice::sort_by_key() for more information.

pub fn sort_by_cached_key<K, F>(&mut self, f: F)

where F: FnMut(&T) -> K, K: Ord,

Orders the elements in this collection leveraging the standard library’s sorting implementation. See slice::sort_by_cached_key() for more information.

pub fn sort_unstable(&mut self)

where T: Ord,

Orders the elements in this collection leveraging the standard library’s sorting implementation. See slice::sort_unstable() for more information.

pub fn sort_unstable_by<F: Fn(&T, &T) -> Ordering>(&mut self, comparison: F)

Orders the elements in this collection leveraging the standard library’s sorting implementation. See slice::sort_unstable_by() for more information.

pub fn sort_unstable_by_key<K, F>(&mut self, f: F)

where F: FnMut(&T) -> K, K: Ord,

Orders the elements in this collection leveraging the standard library’s sorting implementation. See slice::sort_unstable_by_key() for more information.

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 get_by_index(&self, index: usize) -> Option<&T>

Looks up a value by index. If index is greater than or equal to the collections length, None will be returned.

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

Looks up a mutable reference to a value by index. If index is greater than or equal to the collections length, None will be returned.

pub fn index_of_id(&self, id: LotId) -> Option<usize>

Returns the index of id, or None if the id is not contained in this collection.

pub fn id(&self, index: usize) -> Option<LotId>

Returns the id of the entry at index, or None if index is outside of the bounds of this collection.

pub fn key(&self, index: usize) -> Option<LotId>

Returns the LotId associated with a given index. Returns None if index is greater than or equal to the collections length.

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 entries(&self) -> EntryIter<'_, T>

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

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

Returns the first entry in this collection, or None if the collection is empty.

pub fn first_mut(&mut self) -> Option<&mut T>

Returns a mutable reference to the first entry in this collection, or None if the collection is empty.

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

Returns the last entry in this collection, or None if the collection is empty.

pub fn last_mut(&mut self) -> Option<&mut T>

Returns a mutable reference to the last entry in this collection, or None if the collection is empty.

pub fn swap(&mut self, a: usize, b: usize)

Swaps the elements at index a and b.

Internally, this only moves a LotId. The underlying data does not change, and its each value’s associated LotId does not change.

Trait Implementations

impl<T: Clone> Clone for OrderedLots<T>

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

Returns a copy of the value.

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

Performs copy-assignment from source.

impl<T> Debug for OrderedLots<T>

where T: Debug,

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

Formats the value using the given formatter.

impl<T> Default for OrderedLots<T>

fn default() -> Self

Returns the “default value” for a type.

impl<T> FromIterator<T> for OrderedLots<T>

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

Creates a value from an iterator.

impl<T> Index<LotId> for OrderedLots<T>

type Output = T

The returned type after indexing.

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

Performs the indexing (container[index]) operation.

impl<T> Index<usize> for OrderedLots<T>

type Output = T

The returned type after indexing.

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

Performs the indexing (container[index]) operation.

impl<T> IndexMut<LotId> for OrderedLots<T>

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

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

impl<T> IndexMut<usize> for OrderedLots<T>

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

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

impl<'a, T> IntoIterator for &'a OrderedLots<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<T> IntoIterator for OrderedLots<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<'a, T> PartialEq<&'a [T]> for OrderedLots<T>

where T: PartialEq,

fn eq(&self, other: &&'a [T]) -> 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, T, const N: usize> PartialEq<&'a [T; N]> for OrderedLots<T>

where T: PartialEq,

fn eq(&self, other: &&'a [T; N]) -> 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> PartialEq<[T]> for OrderedLots<T>

where T: PartialEq,

fn eq(&self, other: &[T]) -> 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, const N: usize> PartialEq<[T; N]> for OrderedLots<T>

where T: PartialEq,

fn eq(&self, other: &[T; N]) -> 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> PartialEq for OrderedLots<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 OrderedLots<T>

where T: Eq,