Struct OrdinalTotalArrayMap 

pub struct OrdinalTotalArrayMap<K, V, const S: usize> { /* private fields */ }

Like OrdinalTotalMap, but without heap allocation.

Due to limitations of stable Rust, ordinal size must be passed as a third type parameter.

Example

use ordinal_map::map::total::OrdinalTotalArrayMap;
use ordinal_map::Ordinal;

#[derive(Ordinal, Debug)]
enum Color {
    Red,
    Green,
    Blue,
}

let map: OrdinalTotalArrayMap<Color, String, { Color::ORDINAL_SIZE }> =
    OrdinalTotalArrayMap::new(|color| format!("{color:?}").to_lowercase());

assert_eq!("green", map[&Color::Green]);

Implementations

impl<K: Ordinal, V, const S: usize> OrdinalTotalArrayMap<K, V, S>

pub fn try_new<E>(init: impl FnMut(K) -> Result<V, E>) -> Result<Self, E>

Create a new map by initializing each value with a function.

pub fn new(init: impl FnMut(K) -> V) -> Self

Create a new map by initializing each value with a function.

pub fn from_array(array: [V; S]) -> Self

Create a new map from an array of values in ordinal order of keys.

pub const fn len(&self) -> usize

Returns the number of elements in the map, which is always equal to K::ORDINAL_SIZE.

pub const fn is_empty(&self) -> bool

Return true if the map container no elements.

pub fn get<'a>(&'a self, key: &K) -> &'a V

Returns a reference to the value corresponding to the key.

pub fn get_mut<'a>(&'a mut self, key: &K) -> &'a mut V

Returns a mutable reference to the value corresponding to the key.

pub fn as_ref(&self) -> OrdinalTotalArrayMap<K, &V, S>

Return a new map with values as references to values of the original map.

pub fn as_mut(&mut self) -> OrdinalTotalArrayMap<K, &mut V, S>

Return a new map with values as mutable references to values of the original map.

pub fn zip<W>( self, other: OrdinalTotalArrayMap<K, W, S>, ) -> OrdinalTotalArrayMap<K, (V, W), S>

Combine two maps into one.

pub fn map<W>(self, f: impl FnMut(K, V) -> W) -> OrdinalTotalArrayMap<K, W, S>

Map the values of the map.

pub fn map_values<W>( self, f: impl FnMut(V) -> W, ) -> OrdinalTotalArrayMap<K, W, S>

Map the values of the map.

pub fn iter<'a>(&'a self) -> Iter<'a, K, V>

Iterate over the map.

pub fn iter_mut<'a>(&'a mut self) -> IterMut<'a, K, V>

Iterate over the map mutably.

pub fn keys(&self) -> OrdinalValues<K>

Iterate keys of the map, which is equivalent to iterating all possible values of K.

pub fn into_keys(self) -> OrdinalValues<K>

Convert the map into an iterator over keys.

This operation is identical to keys, but added here for consistency with other map implementations.

pub fn values<'a>(&'a self) -> Iter<'a, V>

Iterate values of the map.

pub fn values_array(&self) -> &[V; S]

Values arrays.

pub fn values_mut<'a>(&'a mut self) -> IterMut<'a, V>

Iterate mutable references to values of the map.

pub fn values_array_mut(&mut self) -> &mut [V; S]

Values arrays.

pub fn into_values(self) -> [V; S]

Convert the map into an array of values.

pub fn insert(&mut self, key: K, value: V) -> V

Insert a value into the map, returning the previous value.

Trait Implementations

impl<K, V: Clone, const S: usize> Clone for OrdinalTotalArrayMap<K, V, S>

fn clone(&self) -> Self

Returns a duplicate of the value.

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

Performs copy-assignment from source.

impl<K: Ordinal + Debug, V: Debug, const S: usize> Debug for OrdinalTotalArrayMap<K, V, S>

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

Formats the value using the given formatter.

impl<K: Ordinal, V: Default, const S: usize> Default for OrdinalTotalArrayMap<K, V, S>

fn default() -> Self

Returns the “default value” for a type.

impl<'a, K: Ordinal, V, const S: usize> Index<&'a K> for OrdinalTotalArrayMap<K, V, S>

type Output = V

The returned type after indexing.

fn index(&self, index: &'a K) -> &Self::Output

Performs the indexing (container[index]) operation.

impl<'a, K: Ordinal, V, const S: usize> IndexMut<&'a K> for OrdinalTotalArrayMap<K, V, S>

fn index_mut(&mut self, index: &'a K) -> &mut Self::Output

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

impl<K: Ordinal, V, const S: usize> IntoIterator for OrdinalTotalArrayMap<K, V, S>

type Item = (K, V)

The type of the elements being iterated over.

type IntoIter = IntoIterArray<K, V, S>

Which kind of iterator are we turning this into?

fn into_iter(self) -> Self::IntoIter

Creates an iterator from a value.

impl<'a, K: Ordinal, V, const S: usize> IntoIterator for &'a OrdinalTotalArrayMap<K, V, S>

type Item = (K, &'a V)

The type of the elements being iterated over.

type IntoIter = Iter<'a, K, V>

Which kind of iterator are we turning this into?

fn into_iter(self) -> Self::IntoIter

Creates an iterator from a value.