Struct Linearized

pub struct Linearized<L>
where
    L: ?Sized,
{ /* private fields */ }

Pre-computed output of Linearize::linearize.

StaticMap and StaticCopyMap can be index directly with a Linearize type. That operation computes the output of linearize ad-hoc. While the linearize function is zero cost for many types, you might be using types for which the cost is non-zero or unknown.

In such situations, the Linearized type allows you to cache the output of linearize.

It is guaranteed that the value cached by this type is the output of the linearize function. In particular, the value is less than LENGTH.

Example

fn add_one<L: Linearize>(map: &mut StaticMap<L, u8>, key: L) {
    let key = key.linearized();
    let v = map[key];
    map[key] = v + 1;
}

Trait Implementations

This type implements traits such as Debug, Hash, etc. These implementations operate on the pre-computed usize. In particular, the Debug implementation does not print the name of the original value used to create this object.

Implementations

impl<L> Linearized<L>

where L: ?Sized,

pub fn new(l: &L) -> Self

where L: Linearize,

Pre-computes the linearized value.

This function pre-computes the output of linearize.

The LinearizeExt extension trait provides the linearized function which does the same.

Example

fn get_value<L: Linearize>(map: &StaticMap<L, u8>, key: L) -> u8 {
    map[Linearized::new(&key)]
    // Or: map[key.linearized()]
}

pub const unsafe fn new_unchecked(index: usize) -> Self

Wraps an already computed values.

Safety

The index must be less than L::LENGTH.

pub fn get(self) -> usize

Returns the linearized value.

This function returns the output of linearize that was computed when this object was created.

Example

fn get<L: Linearize>(key: L) {
    assert_eq!(key.linearized().get(), key.linearize());
}

pub fn delinearize(self) -> L

where L: Linearize + Sized,

Returns the value that was used to create this object.

This function returns the output of from_linear_unchecked. This value is required to be the same that was used to create this object.

Example

fn get<L: Linearize + Eq + Debug>(key: L) {
    assert_eq!(key.linearized().delinearize(), key);
}

Trait Implementations

impl<L> Clone for Linearized<L>

where L: ?Sized,

fn clone(&self) -> Self

Returns a copy of the value.

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

Performs copy-assignment from source.

impl<L> Debug for Linearized<L>

where L: ?Sized,

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

Formats the value using the given formatter.

impl<L> Hash for Linearized<L>

where L: ?Sized,

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<L, T> Index<Linearized<L>> for StaticCopyMap<L, T>

where L: Linearize + ?Sized, T: Copy,

type Output = T

The returned type after indexing.

fn index(&self, index: Linearized<L>) -> &Self::Output

Performs the indexing (container[index]) operation.

impl<L, T> Index<Linearized<L>> for StaticMap<L, T>

where L: Linearize + ?Sized,

type Output = T

The returned type after indexing.

fn index(&self, index: Linearized<L>) -> &Self::Output

Performs the indexing (container[index]) operation.

impl<L, T> IndexMut<Linearized<L>> for StaticCopyMap<L, T>

where L: Linearize + ?Sized, T: Copy,

fn index_mut(&mut self, index: Linearized<L>) -> &mut Self::Output

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

impl<L, T> IndexMut<Linearized<L>> for StaticMap<L, T>

where L: Linearize + ?Sized,

fn index_mut(&mut self, index: Linearized<L>) -> &mut Self::Output

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

impl<L> Ord for Linearized<L>

where L: ?Sized,

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<L> PartialEq<usize> for Linearized<L>

where L: ?Sized,

fn eq(&self, other: &usize) -> 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<L> PartialEq for Linearized<L>

where L: ?Sized,

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<L> PartialOrd<usize> for Linearized<L>

where L: ?Sized,

fn partial_cmp(&self, other: &usize) -> 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<L> PartialOrd for Linearized<L>

where L: ?Sized,

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<L> Copy for Linearized<L>

where L: ?Sized,

impl<L> Eq for Linearized<L>

where L: ?Sized,