Enum Direction

#[repr(u8)]
pub enum Direction {
    North = 0,
    East = 1,
    South = 2,
    West = 3,
}

The four cardinal directions: North, East, South, and West.

Variants

North = 0

Upwards

East = 1

Rightwards

South = 2

Downwards

West = 3

Leftwards

Implementations

impl Direction

pub const fn is_vertical(self) -> bool

Returns true if the Direction is North or South.

pub const fn is_horizontal(self) -> bool

Returns true if the Direction is East or West.

Trait Implementations

impl Clone for Direction

fn clone(&self) -> Direction

Returns a copy of the value.

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

Performs copy-assignment from source.

impl Debug for Direction

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

Formats the value using the given formatter.

impl Display for Direction

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

Formats the value using the given formatter.

impl From<Direction> for u8

fn from(enum_value: Direction) -> Self

Converts to this type from the input type.

impl FromStr for Direction

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 Direction

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

fn mul_assign(&mut self, rhs: Transform)

Applies a Transform to the current Direction.

impl Neg for Direction

type Output = Direction

The resulting type after applying the - operator.

fn neg(self) -> Self::Output

Performs the unary - operation.

impl PartialEq for Direction

fn eq(&self, other: &Direction) -> 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 Direction

type Error = TryFromPrimitiveError<Direction>

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 Direction

const NAME: &'static str = "Direction"

type Primitive = u8

type Error = TryFromPrimitiveError<Direction>

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

impl Copy for Direction

impl Eq for Direction

impl StructuralPartialEq for Direction