Enum gridly::prelude::Direction

pub enum Direction {
    Up,
    Down,
    Left,
    Right,
}

The four cardinal directions (up, down, left, right). Direction implements a number of simple helper methods. It also implements VectorLike, which allows it to be used in contexts where a Vector can be used as a unit vector in the given direction (for example, with Vector arithmetic).

Variants

Up

The negative row direction

Down

The positive row direction

Left

The negative column direction

Right

The positive column direction

Methods

impl Direction

#[must_use] pub fn sized_vec(self, length: isize) -> Vector

Return a vector with the given length in this direction

Example:

use gridly::prelude::*;

assert_eq!(Up.sized_vec(2), Vector::new(-2, 0));
assert_eq!(Down.sized_vec(3), Vector::new(3, 0));
assert_eq!(Left.sized_vec(1), Vector::new(0, -1));
assert_eq!(Right.sized_vec(5), Vector::new(0, 5));

#[must_use] pub fn unit_vec(self) -> Vector

Return the unit vector in the given direction.

Example:

use gridly::prelude::*;

assert_eq!(Up.unit_vec(), Vector::new(-1, 0));
assert_eq!(Down.unit_vec(), Vector::new(1, 0));
assert_eq!(Left.unit_vec(), Vector::new(0, -1));
assert_eq!(Right.unit_vec(), Vector::new(0, 1));

#[must_use] pub fn is_vertical(self) -> bool

True if this is Up or Down

Example:

use gridly::direction::*;

assert!(Up.is_vertical());
assert!(Down.is_vertical());
assert!(!Left.is_vertical());
assert!(!Right.is_vertical());

#[must_use] pub fn is_horizontal(self) -> bool

True if this is Left or Right

Example:

use gridly::direction::*;

assert!(!Up.is_horizontal());
assert!(!Down.is_horizontal());
assert!(Left.is_horizontal());
assert!(Right.is_horizontal());

#[must_use] pub fn reverse(self) -> Direction

Reverse this direction (Up → Down, etc)

use gridly::direction::*;

assert_eq!(Up.reverse(), Down);
assert_eq!(Down.reverse(), Up);
assert_eq!(Left.reverse(), Right);
assert_eq!(Right.reverse(), Left);

#[must_use] pub fn clockwise(self) -> Direction

Rotate this direction clockwise

Example:

use gridly::direction::*;

assert_eq!(Up.clockwise(), Right);
assert_eq!(Down.clockwise(), Left);
assert_eq!(Left.clockwise(), Up);
assert_eq!(Right.clockwise(), Down);

#[must_use] pub fn anticlockwise(self) -> Direction

Rotate this direction counterclockwise

Example:

use gridly::direction::*;

assert_eq!(Up.anticlockwise(), Left);
assert_eq!(Down.anticlockwise(), Right);
assert_eq!(Left.anticlockwise(), Down);
assert_eq!(Right.anticlockwise(), Up);

Trait Implementations

impl VectorLike for Direction

A Direction acts like a unit vector in the given direction. This allows it to be used in things like Vector arithmetic.

Example:

use gridly::prelude::*;

assert_eq!(Vector::new(1, 1) + Up, Vector::new(0, 1));
assert_eq!(Location::new(3, 4) - Left, Location::new(3, 5));

#[must_use] fn rows(&self) -> Rows

#[must_use] fn columns(&self) -> Columns

#[must_use] fn as_vector(&self) -> Vector

#[must_use] fn manhattan_length(&self) -> isize

Return the manhattan length of the vector. The manhattan length of a vector is the sum of the absolute values of its components.

#[must_use] fn checked_manhattan_length(&self) -> Option<isize>

Return the manhatten length of the vector, or None if there are any overflows.

#[must_use] fn clockwise(&self) -> Vector

Return a new vector, rotated 90 degrees clockwise.

#[must_use] fn anticlockwise(&self) -> Vector

Return a new vector, rotated 90 degrees counterclockwise.

#[must_use] fn reverse(&self) -> Vector

#[must_use] fn transpose(&self) -> Vector

Swap the rows and columns of this Vector

#[must_use] fn direction(&self) -> Option<Direction>

If the vector is pointing in an orthogonal direction, return that direction

fn get_component<T: Component>(&self) -> T

Generically get either the Rows or Columns of a vector

impl Eq for Direction

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 PartialEq<Direction> for Direction

fn eq(&self, other: &Direction) -> bool

This method tests for self and other values to be equal, and is used by ==.

#[must_use] fn ne(&self, other: &Rhs) -> bool

This method tests for !=.

impl Copy for Direction

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, 

Feeds a slice of this type into the given [Hasher].

impl<T: VectorLike> Add<T> for Direction

Adding a Vector to a Direction is equivelent to adding it to a unit vector in the given direction. Note that, because Direction itself implements VectorLike, this means you can add together a sequence of directions to get a Vector.

Example:

use gridly::vector::Vector;
use gridly::direction::*;

let base = Vector::new(3, 4);

assert_eq!(Up + base, Vector::new(2, 4));
assert_eq!(Down + base, Vector::new(4, 4));
assert_eq!(Right + base, Vector::new(3, 5));
assert_eq!(Left + base, Vector::new(3, 3));

assert_eq!(Up + Right + Up + Up, Vector::new(-3, 1));

type Output = Vector

The resulting type after applying the + operator.

#[must_use] fn add(self, rhs: T) -> Vector

Performs the + operation.

impl<T: VectorLike> Sub<T> for Direction

Subtracting a Vector from a Direction is equivelent to subtracing it from a unit vector in the given direction

Example:

use gridly::vector::Vector;
use gridly::direction::*;

let base = Vector::new(3, 3);

assert_eq!(Up - base, Vector::new(-4, -3));
assert_eq!(Down - base, Vector::new(-2, -3));
assert_eq!(Right - base, Vector::new(-3, -2));
assert_eq!(Left - base, Vector::new(-3, -4));

type Output = Vector

The resulting type after applying the - operator.

#[must_use] fn sub(self, rhs: T) -> Vector

Performs the - operation.

impl Mul<isize> for Direction

Multiplying a Direction by an isize produces a Vector of the given length in the given direction

Example:

use gridly::direction::*;
use gridly::vector::Vector;

assert_eq!(Up * 5, Vector::new(-5, 0));
assert_eq!(Down * 3, Vector::new(3, 0));
assert_eq!(Left * 2, Vector::new(0, -2));
assert_eq!(Right * 4, Vector::new(0, 4));

type Output = Vector

The resulting type after applying the * operator.

#[must_use] fn mul(self, amount: isize) -> Vector

Performs the * operation.

impl Neg for Direction

Negating a Direction reverses it

Example:

use gridly::direction::*;

assert_eq!(-Up, Down);
assert_eq!(-Down, Up);
assert_eq!(-Left, Right);
assert_eq!(-Right, Left);

type Output = Direction

The resulting type after applying the - operator.

#[must_use] fn neg(self) -> Direction

Performs the unary - operation.

impl Debug for Direction

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

Formats the value using the given formatter.