Struct FaceMap 

pub struct FaceMap<V> {
    pub nx: V,
    pub ny: V,
    pub nz: V,
    pub px: V,
    pub py: V,
    pub pz: V,
}

Container for values keyed by Face6s. Always holds exactly six elements.

Fields

nx: V

The value whose key is Face6::NX.

ny: V

The value whose key is Face6::NY.

nz: V

The value whose key is Face6::NZ.

px: V

The value whose key is Face6::PX.

py: V

The value whose key is Face6::PY.

pz: V

The value whose key is Face6::PZ.

Implementations

impl<V> FaceMap<V>

pub fn from_fn(f: impl FnMut(Face6) -> V) -> FaceMap<V>

Constructs a FaceMap by using the provided function to compute a value for each Face6 enum variant.

pub fn negatives<U>(self) -> Vector3D<V, U>

where V: Copy,

Returns a vector containing the values for each negative face.

pub fn positives<U>(self) -> Vector3D<V, U>

where V: Copy,

Returns a vector containing the values for each positive face.

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

Iterate over the map’s key-value pairs by reference, in the same order as Face6::ALL.

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

Iterate over the map’s key-value pairs by mutable reference, in the same order as Face6::ALL.

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

Iterate over the map values by reference, in the same order as Face6::ALL.

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

Iterate over the map values by mutable reference, in the same order as Face6::ALL.

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

Convert to an array, whose elements are arranged in the same order as Face6::ALL.

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

Convert to an iterator, whose items are arranged in the same order as Face6::ALL.

pub fn sum(self) -> V

where V: Add<Output = V>,

Calculates the sum of all values.

This is semantically equivalent to .into_values_iter().sum() but computes the sum using the ops::Add trait. It may be more efficient than involving iterators.

pub fn map<U>(self, f: impl FnMut(Face6, V) -> U) -> FaceMap<U>

Transform values.

pub fn map_ref<'map, U>( &'map self, f: impl FnMut(Face6, &'map V) -> U, ) -> FaceMap<U>

Transform values, taking the input by reference.

pub fn zip<U, R>( self, other: FaceMap<U>, f: impl FnMut(Face6, V, U) -> R, ) -> FaceMap<R>

Combine two FaceMaps using a function applied to each pair of corresponding values.

pub fn with(self, face: Face6, value: V) -> FaceMap<V>

Returns this map with one entry’s value replaced.

This may be used for constructing a map with only one interesting entry:

use all_is_cubes::math::{Face6, FaceMap};

assert_eq!(
    FaceMap::default().with(Face6::PY, 10),
    {
        let mut m = FaceMap::default();
        m[Face6::PY] = 10;
        m
    },
);

pub fn rotate(self, rotation: GridRotation) -> FaceMap<V>

Shuffle the values in this map according to the given rotation.

impl<V> FaceMap<V>

where V: Clone,

pub fn splat(value: V) -> FaceMap<V>

Constructs a FaceMap containing clones of the provided value.

impl<V> FaceMap<V>

where V: Copy,

pub const fn splat_copy(value: V) -> FaceMap<V>

Constructs a FaceMap containing copies of the provided value.

This is practically identical to FaceMap::splat() except that it is a const fn. It may be removed from future major versions once Rust supports const trait function calls.

Trait Implementations

impl<V> Add for FaceMap<V>

where V: Add,

fn add(self, other: FaceMap<V>) -> FaceMap<<V as Add>::Output>

Apply the operator pairwise to the values for all six faces.

type Output = FaceMap<<V as Add>::Output>

The resulting type after applying the + operator.

impl<V> AddAssign for FaceMap<V>

where V: AddAssign,

fn add_assign(&mut self, rhs: FaceMap<V>)

Apply the operator pairwise to the values for all six faces.

impl<'arbitrary, V> Arbitrary<'arbitrary> for FaceMap<V>

where V: Arbitrary<'arbitrary>,

fn arbitrary(u: &mut Unstructured<'arbitrary>) -> Result<FaceMap<V>, Error>

Generate an arbitrary value of Self from the given unstructured data.

fn arbitrary_take_rest(u: Unstructured<'arbitrary>) -> Result<FaceMap<V>, Error>

Generate an arbitrary value of Self from the entirety of the given unstructured data.

fn size_hint(depth: usize) -> (usize, Option<usize>)

Get a size hint for how many bytes out of an Unstructured this type needs to construct itself.

fn try_size_hint( depth: usize, ) -> Result<(usize, Option<usize>), MaxRecursionReached>

Get a size hint for how many bytes out of an Unstructured this type needs to construct itself.

impl<V> BitAnd for FaceMap<V>

where V: BitAnd,

fn bitand(self, other: FaceMap<V>) -> FaceMap<<V as BitAnd>::Output>

Apply the operator pairwise to the values for all six faces.

type Output = FaceMap<<V as BitAnd>::Output>

The resulting type after applying the & operator.

impl<V> BitAndAssign for FaceMap<V>

where V: BitAndAssign,

fn bitand_assign(&mut self, rhs: FaceMap<V>)

Apply the operator pairwise to the values for all six faces.

impl<V> BitOr for FaceMap<V>

where V: BitOr,

fn bitor(self, other: FaceMap<V>) -> FaceMap<<V as BitOr>::Output>

Apply the operator pairwise to the values for all six faces.

type Output = FaceMap<<V as BitOr>::Output>

The resulting type after applying the | operator.

impl<V> BitOrAssign for FaceMap<V>

where V: BitOrAssign,

fn bitor_assign(&mut self, rhs: FaceMap<V>)

Apply the operator pairwise to the values for all six faces.

impl<V> BitXor for FaceMap<V>

where V: BitXor,

fn bitxor(self, other: FaceMap<V>) -> FaceMap<<V as BitXor>::Output>

Apply the operator pairwise to the values for all six faces.

type Output = FaceMap<<V as BitXor>::Output>

The resulting type after applying the ^ operator.

impl<V> BitXorAssign for FaceMap<V>

where V: BitXorAssign,

fn bitxor_assign(&mut self, rhs: FaceMap<V>)

Apply the operator pairwise to the values for all six faces.

impl<V> Clone for FaceMap<V>

where V: Clone,

fn clone(&self) -> FaceMap<V>

Returns a duplicate of the value.

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

Performs copy-assignment from source.

impl<V> Debug for FaceMap<V>

where V: Debug + PartialEq,

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

In addition to the usual formatting behaviors, FaceMap will detect whether elements are equal and avoid redundant printing.

impl<V> Default for FaceMap<V>

where V: Default,

fn default() -> FaceMap<V>

Returns the “default value” for a type.

impl<V> Div for FaceMap<V>

where V: Div,

fn div(self, other: FaceMap<V>) -> FaceMap<<V as Div>::Output>

Apply the operator pairwise to the values for all six faces.

type Output = FaceMap<<V as Div>::Output>

The resulting type after applying the / operator.

impl<V> DivAssign for FaceMap<V>

where V: DivAssign,

fn div_assign(&mut self, rhs: FaceMap<V>)

Apply the operator pairwise to the values for all six faces.

impl<V> Exhaust for FaceMap<V>

where V: Exhaust,

type Iter = ExhaustFaceMapIter<V>

Iterator type returned by Self::exhaust_factories(). See the trait documentation for what properties this iterator should have.

type Factory = ExhaustFaceMapFactory<V>

Data which can be used to construct Self.

fn exhaust_factories() -> <FaceMap<V> as Exhaust>::Iter

Returns an iterator over factories for all values of this type.

fn from_factory(factory: <FaceMap<V> as Exhaust>::Factory) -> FaceMap<V>

Construct a concrete value of this type from a Self::Factory value produced by its Self::Iter.

fn exhaust() -> Iter<Self>

Returns an iterator over all values of this type.

impl<V> Hash for FaceMap<V>

where V: Hash,

fn hash<__H>(&self, state: &mut __H)

where __H: Hasher,

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<V> Index<Face6> for FaceMap<V>

type Output = V

The returned type after indexing.

fn index(&self, face: Face6) -> &V

Performs the indexing (container[index]) operation.

impl<V> IndexMut<Face6> for FaceMap<V>

fn index_mut(&mut self, face: Face6) -> &mut V

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

impl<V> IntoIterator for FaceMap<V>

type Item = (Face6, V)

The type of the elements being iterated over.

type IntoIter = <[(Face6, V); 6] as IntoIterator>::IntoIter

Which kind of iterator are we turning this into?

fn into_iter(self) -> <FaceMap<V> as IntoIterator>::IntoIter

Creates an iterator from a value.

impl<V> Mul for FaceMap<V>

where V: Mul,

fn mul(self, other: FaceMap<V>) -> FaceMap<<V as Mul>::Output>

Apply the operator pairwise to the values for all six faces.

type Output = FaceMap<<V as Mul>::Output>

The resulting type after applying the * operator.

impl<V> MulAssign for FaceMap<V>

where V: MulAssign,

fn mul_assign(&mut self, rhs: FaceMap<V>)

Apply the operator pairwise to the values for all six faces.

impl<V> PartialEq for FaceMap<V>

where V: PartialEq,

fn eq(&self, other: &FaceMap<V>) -> 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<V> Rem for FaceMap<V>

where V: Rem,

fn rem(self, other: FaceMap<V>) -> FaceMap<<V as Rem>::Output>

Apply the operator pairwise to the values for all six faces.

type Output = FaceMap<<V as Rem>::Output>

The resulting type after applying the % operator.

impl<V> RemAssign for FaceMap<V>

where V: RemAssign,

fn rem_assign(&mut self, rhs: FaceMap<V>)

Apply the operator pairwise to the values for all six faces.

impl<V> Sub for FaceMap<V>

where V: Sub,

fn sub(self, other: FaceMap<V>) -> FaceMap<<V as Sub>::Output>

Apply the operator pairwise to the values for all six faces.

type Output = FaceMap<<V as Sub>::Output>

The resulting type after applying the - operator.

impl<V> SubAssign for FaceMap<V>

where V: SubAssign,

fn sub_assign(&mut self, rhs: FaceMap<V>)

Apply the operator pairwise to the values for all six faces.

impl<V> Copy for FaceMap<V>

where V: Copy,

impl<V> Eq for FaceMap<V>

where V: Eq,

impl<V> StructuralPartialEq for FaceMap<V>