Enum Transform

#[repr(u8)]
pub enum Transform {
    Identity = 0,
    Rotate90 = 1,
    Rotate180 = 2,
    Rotate270 = 3,
    FlipHorizontal = 4,
    FlipDiagonal = 5,
    FlipVertical = 6,
    FlipAntiDiagonal = 7,
}

The eight transformations that can be applied to a 2D grid.

Variants

Identity = 0

No transformation: (x, y) -> ( x, y)

Rotate90 = 1

Rotate 90 degrees clockwise: (x, y) -> ( y, -x)

Rotate180 = 2

One half turn: (x, y) -> (-x, -y)

Rotate270 = 3

Rotate 270 degrees clockwise: (x, y) -> (-y, x)

FlipHorizontal = 4

Flip around the vertical axis: (x, y) -> (-x, y)

FlipDiagonal = 5

Flip around the main diagonal: (x, y) -> ( y, x)

FlipVertical = 6

Flip around the horizontal axis: (x, y) -> ( x, -y)

FlipAntiDiagonal = 7

Flip around the anti-diagonal: (x, y) -> (-y, -x)

Implementations

impl Transform

pub fn is_identity(self) -> bool

Returns true if the Transform is the Identity Transform.

pub const fn is_rotation(self) -> bool

Returns true if the Transform is a rotation.

pub const fn is_flip(self) -> bool

Returns true if the Transform is a flip.

Trait Implementations

impl Clone for Transform

fn clone(&self) -> Transform

Returns a copy of the value.

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

Performs copy-assignment from source.

impl Debug for Transform

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

Formats the value using the given formatter.

impl Display for Transform

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

Formats the value using the given formatter.

impl From<Transform> for u8

fn from(enum_value: Transform) -> Self

Converts to this type from the input type.

impl FromStr for Transform

type Err = &'static str

The associated error which can be returned from parsing.

fn from_str(s: &str) -> Result<Self, Self::Err>

Parses a string s to return a value of this type.

impl Hash for Transform

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 Mul<Transform> for Direction

fn mul(self, rhs: Transform) -> Self::Output

Applies a Transform to the current Direction.

Panics

This function uses unwrap() internally but will never panic because the transformation math guarantees that the result will always be a valid Direction value (0-3).

type Output = Direction

The resulting type after applying the * operator.

impl Mul for Transform

type Output = Transform

The resulting type after applying the * operator.

fn mul(self, rhs: Self) -> Self::Output

Performs the * operation.

impl MulAssign<Transform> for Direction

fn mul_assign(&mut self, rhs: Transform)

Applies a Transform to the current Direction.

impl MulAssign for Transform

fn mul_assign(&mut self, rhs: Self)

Performs the *= operation.

impl Neg for Transform

type Output = Transform

The resulting type after applying the - operator.

fn neg(self) -> Self::Output

Performs the unary - operation.

impl PartialEq for Transform

fn eq(&self, other: &Transform) -> 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 TryFrom<u8> for Transform

type Error = TryFromPrimitiveError<Transform>

The type returned in the event of a conversion error.

fn try_from(number: u8) -> Result<Self, TryFromPrimitiveError<Self>>

Performs the conversion.

impl TryFromPrimitive for Transform

const NAME: &'static str = "Transform"

type Primitive = u8

type Error = TryFromPrimitiveError<Transform>

fn try_from_primitive( number: Self::Primitive, ) -> Result<Self, TryFromPrimitiveError<Self>>

impl Copy for Transform

impl Eq for Transform

impl StructuralPartialEq for Transform