Struct EnumMap 

pub struct EnumMap<Ids: MapEnum, T>(/* private fields */);

Array which using enum as index

Implementations

impl<Ids: MapEnum, T> EnumMap<Ids, T>

pub const fn from_array(data: <Ids::Array as Array>::Map<T>) -> Self

Create map from array, recomand using map_new or map_enum!(if require const or move value) instead

pub const fn as_array(&self) -> &<Ids::Array as Array>::Map<T>

Returns a shared reference to the underlying array.

pub const fn as_array_mut(&mut self) -> &mut <Ids::Array as Array>::Map<T>

Returns a mutable reference to the underlying array.

pub const fn into_array(self) -> <Ids::Array as Array>::Map<T>

Consumes the enum map and returns the underlying array.

pub const fn remap<TIds: MapEnum<Array = Ids::Array>>( &self, ) -> &EnumMap<TIds, T>

Reinterprets the enum map as being indexed by a different enum type that shares the same underlying array.

pub const fn remap_mut<TIds: MapEnum<Array = Ids::Array>>( &mut self, ) -> &mut EnumMap<TIds, T>

Mutable version of remap.

pub fn map_new(map: impl FnMut(Ids::Discriminant) -> T) -> Self

Create map by mapping closure, map will call excctally once for each enum variant, using map_enum! instead if require const or move value

pub const fn map_as_ref<'a>(&'a self) -> EnumMap<Ids, &'a T>

Creates a new enum map where each element references the corresponding element in self.

pub const fn map_as_mut<'a>(&'a mut self) -> EnumMap<Ids, &'a mut T>

Creates a new enum map where each element mutably references the corresponding element in self.

pub const fn transparent_wrap<U: TransparentWrapper<T>>(self) -> EnumMap<Ids, U>

Wraps each element of the map in a TransparentWrapper, safe because the repr is identical.

pub const fn transparent_peel<U>(self) -> EnumMap<Ids, U>

where T: TransparentWrapper<U>,

Unwraps (peels) each element from a TransparentWrapper, safe because the repr is identical.

impl<Ids: MapEnum + PlainMapEnum, T> EnumMap<Ids, T>

pub const fn cget(&self, index: &Ids) -> &T

Gets a reference to the element at the index given by the enum variant index. This is a const-compatible version of the Index trait.

pub const fn cget_mut(&mut self, index: &Ids) -> &mut T

Gets a mutable reference to the element at the index given by the enum variant index. This is a const-compatible version of the IndexMut trait.

impl<Ids0: MapEnum<Discriminant: Clone>, Ids1: MapEnum, T> EnumMap<Ids0, EnumMap<Ids1, T>>

pub fn map_new2( map: impl FnMut(Ids0::Discriminant, Ids1::Discriminant) -> T, ) -> Self

Creates a 2-level enum map by invoking the closure for every combination of (Ids0, Ids1) variants.

Trait Implementations

impl<Ids: MapEnum, T> AsMut<<<Ids as MapEnum>::Array as Array>::Map<T>> for EnumMap<Ids, T>

fn as_mut(&mut self) -> &mut <Ids::Array as Array>::Map<T>

Converts this type into a mutable reference of the (usually inferred) input type.

impl<Ids: MapEnum, T> AsRef<<<Ids as MapEnum>::Array as Array>::Map<T>> for EnumMap<Ids, T>

fn as_ref(&self) -> &<Ids::Array as Array>::Map<T>

Converts this type into a shared reference of the (usually inferred) input type.

impl<Ids: MapEnum<Array: Array<Map<Fld>: Copy>>, Fld: BitsCast> BitsCast for EnumMap<Ids, Fld>

const BITS: u32

fn from_underlying<Bits: PrimaryInt>(v: Bits) -> Self

Convert from underlying int, data is store at lowest Self::BITS, higher bits can be any value

fn into_underlying<Bits: PrimaryInt>(sf: Self) -> Bits

Convert into underlying int, data must store at lowest Self::BITS, higher bits can be any value

impl<Ids: MapEnum<Array: Array<Map<T>: Clone>>, T> Clone for EnumMap<Ids, T>

fn clone(&self) -> Self

Returns a duplicate of the value.

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

Performs copy-assignment from source.

impl<Ids: MapEnum<Array: Array<Map<T>: ConstDefault>>, T> ConstDefault for EnumMap<Ids, T>

const DEFAULT: Self

The constant default value.

impl<Ids: MapEnum<Array: Array<Map<T>: Copy>>, T> Copy for EnumMap<Ids, T>

impl<Ids: MapEnum<Array: Array<Map<T>: Debug>>, T> Debug for EnumMap<Ids, T>

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

Formats the value using the given formatter.

impl<Ids: MapEnum<Array: Array<Map<T>: Default>>, T> Default for EnumMap<Ids, T>

fn default() -> Self

Returns the “default value” for a type.

impl<Ids: MapEnum<Array: Array<Map<T>: Eq>>, T> Eq for EnumMap<Ids, T>

impl<'i, Ids: MapEnum, T> Index<&'i Ids> for EnumMap<Ids, T>

type Output = T

The returned type after indexing.

fn index(&self, index: &'i Ids) -> &Self::Output

Performs the indexing (container[index]) operation.

impl<Ids: MapEnum, T> Index<Ids> for EnumMap<Ids, T>

type Output = T

The returned type after indexing.

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

Performs the indexing (container[index]) operation.

impl<'i, Ids: MapEnum, T> IndexMut<&'i Ids> for EnumMap<Ids, T>

fn index_mut(&mut self, index: &'i Ids) -> &mut Self::Output

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

impl<Ids: MapEnum, T> IndexMut<Ids> for EnumMap<Ids, T>

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

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

impl<Ids: MapEnum<Array: Array<Map<T>: Ord>>, T> Ord for EnumMap<Ids, T>

fn cmp(&self, other: &Self) -> Ordering

This method returns an Ordering between self and other.

fn max(self, other: Self) -> Self

where Self: Sized,

Compares and returns the maximum of two values.

fn min(self, other: Self) -> Self

where Self: Sized,

Compares and returns the minimum of two values.

fn clamp(self, min: Self, max: Self) -> Self

where Self: Sized,

Restrict a value to a certain interval.

impl<Ids: MapEnum<Array: Array<Map<T>: PartialEq>>, T> PartialEq for EnumMap<Ids, T>

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<Ids: MapEnum<Array: Array<Map<T>: PartialOrd>>, T> PartialOrd for EnumMap<Ids, T>

fn partial_cmp(&self, other: &Self) -> Option<Ordering>

This method returns an ordering between self and other values if one exists.

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

Tests less than (for self and other) and is used by the < operator.

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

Tests less than or equal to (for self and other) and is used by the <= operator.

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

Tests greater than (for self and other) and is used by the > operator.

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

Tests greater than or equal to (for self and other) and is used by the >= operator.

impl<Ids: MapEnum<Array: Array<Map<T>: Pod>> + 'static, T: 'static> Pod for EnumMap<Ids, T>

impl<Ids: MapEnum, T: TransparentWrapper<U>, U> TransparentWrapper<EnumMap<Ids, U>> for EnumMap<Ids, T>

fn wrap(s: Inner) -> Self

where Self: Sized, Inner: Sized,

Convert the inner type into the wrapper type.

fn wrap_ref(s: &Inner) -> &Self

Convert a reference to the inner type into a reference to the wrapper type.

fn wrap_mut(s: &mut Inner) -> &mut Self

Convert a mutable reference to the inner type into a mutable reference to the wrapper type.

fn wrap_slice(s: &[Inner]) -> &[Self]

where Self: Sized, Inner: Sized,

Convert a slice to the inner type into a slice to the wrapper type.

fn wrap_slice_mut(s: &mut [Inner]) -> &mut [Self]

where Self: Sized, Inner: Sized,

Convert a mutable slice to the inner type into a mutable slice to the wrapper type.

fn peel(s: Self) -> Inner

where Self: Sized, Inner: Sized,

Convert the wrapper type into the inner type.

fn peel_ref(s: &Self) -> &Inner

Convert a reference to the wrapper type into a reference to the inner type.

fn peel_mut(s: &mut Self) -> &mut Inner

Convert a mutable reference to the wrapper type into a mutable reference to the inner type.

fn peel_slice(s: &[Self]) -> &[Inner]

where Self: Sized, Inner: Sized,

Convert a slice to the wrapped type into a slice to the inner type.

fn peel_slice_mut(s: &mut [Self]) -> &mut [Inner]

where Self: Sized, Inner: Sized,

Convert a mutable slice to the wrapped type into a mutable slice to the inner type.

impl<Ids: MapEnum<Array: Array<Map<T>: Zeroable>>, T> Zeroable for EnumMap<Ids, T>

fn zeroed() -> Self

Calls zeroed.