Struct EnumTable

pub struct EnumTable<K: Enumable, V, const N: usize> { /* private fields */ }

A table that associates each variant of an enumeration with a value.

EnumTable is a generic struct that uses an enumeration as keys and stores associated values. It provides constant-time access to the values based on the enumeration variant. This is particularly useful when you want to map enum variants to specific values without the overhead of a HashMap.

Type Parameters

• K: The enumeration type that implements the Enumable trait. This trait ensures that the enum provides a static array of its variants and a count of these variants.
• V: The type of values to be associated with each enum variant.
• N: The number of variants in the enum, which should match the length of the static array of variants provided by the Enumable trait.

Note

The new method allows for the creation of an EnumTable in const contexts, but it does not perform compile-time checks. For enhanced compile-time safety and convenience, it is advisable to use the crate::et macro or crate::builder::EnumTableBuilder, which provide these checks.

Examples

use enum_table::{EnumTable, Enumable};

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

// Create an EnumTable using the new_with_fn method
let table = EnumTable::<Color, &'static str, { Color::COUNT }>::new_with_fn(|color| match color {
    Color::Red => "Red",
    Color::Green => "Green",
    Color::Blue => "Blue",
});

// Access values associated with enum variants
assert_eq!(table.get(&Color::Red), &"Red");
assert_eq!(table.get(&Color::Green), &"Green");
assert_eq!(table.get(&Color::Blue), &"Blue");

Implementations

impl<K: Enumable, V, const N: usize> EnumTable<K, V, N>

pub const fn new(table: [(usize, V); N]) -> Self

Creates a new EnumTable with the given table of discriminants and values. Typically, you would use the crate::et macro or the crate::builder::EnumTableBuilder instead.

Arguments

• table - An array of tuples where each tuple contains a discriminant of an enumeration variant and its associated value.

pub fn new_with_fn(f: impl FnMut(&K) -> V) -> Self

Create a new EnumTable with a function that takes a variant and returns a value. If you want to define it in const, use crate::et macro Creates a new EnumTable using a function to generate values for each variant.

Arguments

• f - A function that takes a reference to an enumeration variant and returns a value to be associated with that variant.

pub fn try_new_with_fn<E>( f: impl FnMut(&K) -> Result<V, E>, ) -> Result<Self, (&'static K, E)>

Creates a new EnumTable using a function that returns a Result for each variant.

This method applies the provided closure to each variant of the enum. If the closure returns Ok(value) for all variants, an EnumTable is constructed and returned as Ok(Self). If the closure returns Err(e) for any variant, the construction is aborted and Err((variant, e)) is returned, where variant is the enum variant that caused the error.

Arguments

• f - A closure that takes a reference to an enum variant and returns a Result<V, E>.

Returns

• Ok(Self) if all variants succeed.
• Err((variant, e)) if any variant fails, containing the failing variant and the error.

pub fn checked_new_with_fn( f: impl FnMut(&K) -> Option<V>, ) -> Result<Self, &'static K>

Creates a new EnumTable using a function that returns an Option for each variant.

This method applies the provided closure to each variant of the enum. If the closure returns Some(value) for all variants, an EnumTable is constructed and returned as Ok(Self). If the closure returns None for any variant, the construction is aborted and Err(variant) is returned, where variant is the enum variant that caused the failure.

Arguments

• f - A closure that takes a reference to an enum variant and returns an Option<V>.

Returns

• Ok(Self) if all variants succeed.
• Err(variant) if any variant fails, containing the failing variant.

pub const fn get(&self, variant: &K) -> &V

Returns a reference to the value associated with the given enumeration variant.

Arguments

• variant - A reference to an enumeration variant.

pub const fn get_mut(&mut self, variant: &K) -> &mut V

Returns a mutable reference to the value associated with the given enumeration variant.

Arguments

• variant - A reference to an enumeration variant.

pub const fn set(&mut self, variant: &K, value: V) -> V

Sets the value associated with the given enumeration variant.

Arguments

• variant - A reference to an enumeration variant.
• value - The new value to associate with the variant.

Returns

The old value associated with the variant.

pub const fn len(&self) -> usize

Returns the number of generic N

pub const fn is_empty(&self) -> bool

Returns false since the table is never empty.

pub fn keys(&self) -> impl Iterator<Item = &K>

Returns an iterator over references to the keys in the table.

pub fn values(&self) -> impl Iterator<Item = &V>

Returns an iterator over references to the values in the table.

pub fn values_mut(&mut self) -> impl Iterator<Item = &mut V>

Returns an iterator over mutable references to the values in the table.

pub fn iter(&self) -> impl Iterator<Item = (&K, &V)>

Returns an iterator over mutable references to the values in the table.

pub fn iter_mut(&mut self) -> impl Iterator<Item = (&K, &mut V)>

Returns an iterator over mutable references to the values in the table.

Trait Implementations

impl<K: Enumable, V: Clone, const N: usize> Clone for EnumTable<K, V, N>

fn clone(&self) -> Self

Returns a duplicate of the value.

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

Performs copy-assignment from source.

impl<K: Enumable + Debug, V: Debug, const N: usize> Debug for EnumTable<K, V, N>

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

Formats the value using the given formatter.

impl<K: Enumable, V: Default, const N: usize> Default for EnumTable<K, V, N>

fn default() -> Self

Returns the “default value” for a type.

impl<K: Enumable, V: Hash, const N: usize> Hash for EnumTable<K, V, N>

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<K: Enumable, V, const N: usize> Index<K> for EnumTable<K, V, N>

type Output = V

The returned type after indexing.

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

Performs the indexing (container[index]) operation.

impl<K: Enumable, V, const N: usize> IndexMut<K> for EnumTable<K, V, N>

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

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

impl<K: Enumable, V: PartialEq, const N: usize> PartialEq for EnumTable<K, V, N>

fn eq(&self, other: &Self) -> bool

Tests for self and other values to be equal, and is used by ==.

fn ne(&self, other: &Rhs) -> bool

Tests for !=. The default implementation is almost always sufficient, and should not be overridden without very good reason.

impl<K: Enumable, V: Eq, const N: usize> Eq for EnumTable<K, V, N>