[−][src]Enum gridly::direction::Direction
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
The negative row direction
The positive row direction
The negative column direction
The positive column direction
Methods
impl Direction
[src]
pub fn sized_vec(self, length: isize) -> Vector
[src]
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
[src]
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
[src]
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
[src]
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
[src]
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
[src]
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
[src]
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
[src]
A Direction
acts like a unit vector in the given direction
fn rows(&self) -> Rows
[src]
fn columns(&self) -> Columns
[src]
fn as_vector(&self) -> Vector
[src]
fn manhattan_length(&self) -> isize
[src]
fn checked_manhattan_length(&self) -> Option<isize>
[src]
fn clockwise(&self) -> Vector
[src]
fn anticlockwise(&self) -> Vector
[src]
fn reverse(&self) -> Vector
[src]
fn get_component<T: Component>(&self) -> T
[src]
fn transpose(&self) -> Vector
[src]
fn direction(&self) -> Option<Direction>
[src]
impl Eq for Direction
[src]
impl Clone for Direction
[src]
impl PartialEq<Direction> for Direction
[src]
impl Copy for Direction
[src]
impl Hash for Direction
[src]
fn hash<__H: Hasher>(&self, state: &mut __H)
[src]
fn hash_slice<H>(data: &[Self], state: &mut H) where
H: Hasher,
1.3.0[src]
H: Hasher,
impl<T: VectorLike> Add<T> for Direction
[src]
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
[src]
impl<T: VectorLike> Sub<T> for Direction
[src]
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
[src]
impl Mul<isize> for Direction
[src]
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
[src]
impl Neg for Direction
[src]
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
[src]
impl Debug for Direction
[src]
Auto Trait Implementations
impl Send for Direction
impl Unpin for Direction
impl Sync for Direction
impl UnwindSafe for Direction
impl RefUnwindSafe for Direction
Blanket Implementations
impl<T> ToOwned for T where
T: Clone,
[src]
T: Clone,
type Owned = T
The resulting type after obtaining ownership.
fn to_owned(&self) -> T
[src]
fn clone_into(&self, target: &mut T)
[src]
impl<T, U> Into<U> for T where
U: From<T>,
[src]
U: From<T>,
impl<T> From<T> for T
[src]
impl<T, U> TryFrom<U> for T where
U: Into<T>,
[src]
U: Into<T>,
type Error = Infallible
The type returned in the event of a conversion error.
fn try_from(value: U) -> Result<T, <T as TryFrom<U>>::Error>
[src]
impl<T, U> TryInto<U> for T where
U: TryFrom<T>,
[src]
U: TryFrom<T>,
type Error = <U as TryFrom<T>>::Error
The type returned in the event of a conversion error.
fn try_into(self) -> Result<U, <U as TryFrom<T>>::Error>
[src]
impl<T> BorrowMut<T> for T where
T: ?Sized,
[src]
T: ?Sized,
fn borrow_mut(&mut self) -> &mut T
[src]
impl<T> Borrow<T> for T where
T: ?Sized,
[src]
T: ?Sized,
impl<T> Any for T where
T: 'static + ?Sized,
[src]
T: 'static + ?Sized,