Enum gridly::direction::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.

Variants

Up

The negative row direction

Down

The positive row direction

Left

The negative column direction

Right

The positive column direction

Methods

impl Direction

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));

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));

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());

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());

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);

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);

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

fn rows(&self) -> Rows

fn columns(&self) -> Columns

fn as_vector(&self) -> Vector

fn manhattan_length(&self) -> isize

Return the Manhattan length of the vector

fn checked_manhattan_length(&self) -> Option<isize>

fn clockwise(&self) -> Vector

Return a new vector, rotated 90 degrees clockwise.

fn anticlockwise(&self) -> Vector

Return a new vector, rotated 90 degrees counterclockwise.

fn reverse(&self) -> Vector

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

Generically get either the Rows or Columns of a vector

fn transpose(&self) -> Vector

Swap the rows and columns of this Vector

fn direction(&self) -> Option<Direction>

If the vector is pointing in an orthogonal direction, return that 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 Copy for Direction

impl Eq for Direction

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

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

Formats the value using the given formatter.

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(0, 0);

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

type Output = Vector

The resulting type after applying the - operator.

fn sub(self, rhs: T) -> Vector

Performs the - operation.

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

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));

type Output = Vector

The resulting type after applying the + operator.

fn add(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.

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.

fn neg(self) -> Direction

Performs the unary - operation.

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].