Struct AxisDiff

pub struct AxisDiff<T: AxisDimension> { /* private fields */ }

AxisDiff (the base for ColDiff or RowDiff) specifies a difference between two coordinate points on a terminal grid. (i.e., a coordinate of a vector on the terminal cell grid)

Implementations

impl<T: AxisDimension> AxisDiff<T>

pub fn new(v: i32) -> Self

Create a new AxisDiff from an i32. Any i32 value is valid.

pub fn raw_value(self) -> i32

Unpack the AxisDiff to receive the raw i32 value.

pub fn from_origin(self) -> AxisIndex<T>

Calculate the AxisIndex that has the specified AxisDiff to the origin (i.e., 0). Technically this just converts an AxisIndex into an AxisDiff, but is semantically more explicit.

Examples:

use unsegen::base::{ColIndex, ColDiff};
assert_eq!(ColDiff::new(27).from_origin(), ColIndex::new(27));

pub fn try_into_positive(self) -> Result<PositiveAxisDiff<T>, Self>

Try to convert the current value into a PositiveAxisDiff. If the conversion fails, the original value is returned.

Examples:

use unsegen::base::{ColDiff, Width};
assert_eq!(ColDiff::new(27).try_into_positive(), Ok(Width::new(27).unwrap()));
assert_eq!(ColDiff::new(0).try_into_positive(), Ok(Width::new(0).unwrap()));
assert_eq!(ColDiff::new(-37).try_into_positive(), Err(ColDiff::new(-37)));

pub fn abs(self) -> PositiveAxisDiff<T>

Convert the current value into a PositiveAxisDiff by taking the absolute value of the axis difference.

Examples:

use unsegen::base::{ColDiff, Width};
assert_eq!(ColDiff::new(27).abs(), Width::new(27).unwrap());
assert_eq!(ColDiff::new(0).abs(), Width::new(0).unwrap());
assert_eq!(ColDiff::new(-37).abs(), Width::new(37).unwrap());

pub fn positive_or_zero(self) -> PositiveAxisDiff<T>

Clamp the value into a positive or zero range

Examples:

use unsegen::base::ColDiff;
assert_eq!(ColDiff::new(27).positive_or_zero(), ColDiff::new(27));
assert_eq!(ColDiff::new(0).positive_or_zero(), ColDiff::new(0));
assert_eq!(ColDiff::new(-37).positive_or_zero(), ColDiff::new(0));

Trait Implementations

impl<T: AxisDimension, I: Into<AxisDiff<T>>> Add<I> for AxisDiff<T>

type Output = AxisDiff<T>

The resulting type after applying the + operator.

fn add(self, rhs: I) -> Self

Performs the + operation.

impl<T: AxisDimension, I: Into<AxisDiff<T>>> AddAssign<I> for AxisDiff<T>

fn add_assign(&mut self, rhs: I)

Performs the += operation.

impl<T: Clone + AxisDimension> Clone for AxisDiff<T>

fn clone(&self) -> AxisDiff<T>

Returns a duplicate of the value.

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

Performs copy-assignment from source.

impl<T: Debug + AxisDimension> Debug for AxisDiff<T>

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

Formats the value using the given formatter.

impl<T: AxisDimension> Div<i32> for AxisDiff<T>

type Output = AxisDiff<T>

The resulting type after applying the / operator.

fn div(self, rhs: i32) -> Self::Output

Performs the / operation.

impl<T: AxisDimension> From<i32> for AxisDiff<T>

fn from(v: i32) -> Self

Converts to this type from the input type.

impl<T: AxisDimension> Into<AxisDiff<T>> for PositiveAxisDiff<T>

fn into(self) -> AxisDiff<T>

Converts this type into the (usually inferred) input type.

impl<T: AxisDimension> Into<i32> for AxisDiff<T>

fn into(self) -> i32

Converts this type into the (usually inferred) input type.

impl<T: AxisDimension> Mul<i32> for AxisDiff<T>

type Output = AxisDiff<T>

The resulting type after applying the * operator.

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

Performs the * operation.

impl<T: AxisDimension> Neg for AxisDiff<T>

type Output = AxisDiff<T>

The resulting type after applying the - operator.

fn neg(self) -> Self::Output

Performs the unary - operation.

impl<T: Ord + AxisDimension> Ord for AxisDiff<T>

fn cmp(&self, other: &AxisDiff<T>) -> Ordering

This method returns an Ordering between self and other.

fn max(self, other: Self) -> Self

where Self: Sized,

Compares and returns the maximum of two values.

fn min(self, other: Self) -> Self

where Self: Sized,

Compares and returns the minimum of two values.

fn clamp(self, min: Self, max: Self) -> Self

where Self: Sized,

Restrict a value to a certain interval.

impl<T: AxisDimension, I: Into<AxisDiff<T>> + Copy> PartialEq<I> for AxisDiff<T>

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

Tests for self and other values to be equal, and is used by ==.

const 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<T: AxisDimension, I: Into<AxisDiff<T>> + Copy> PartialOrd<I> for AxisDiff<T>

fn partial_cmp(&self, other: &I) -> Option<Ordering>

This method returns an ordering between self and other values if one exists.

fn lt(&self, other: &Rhs) -> bool

Tests less than (for self and other) and is used by the < operator.

fn le(&self, other: &Rhs) -> bool

Tests less than or equal to (for self and other) and is used by the <= operator.

fn gt(&self, other: &Rhs) -> bool

Tests greater than (for self and other) and is used by the > operator.

fn ge(&self, other: &Rhs) -> bool

Tests greater than or equal to (for self and other) and is used by the >= operator.

impl<T: AxisDimension, I: Into<AxisDiff<T>>> Rem<I> for AxisDiff<T>

type Output = AxisDiff<T>

The resulting type after applying the % operator.

fn rem(self, modulus: I) -> Self

Performs the % operation.

impl<T: AxisDimension, I: Into<AxisDiff<T>>> Sub<I> for AxisDiff<T>

type Output = AxisDiff<T>

The resulting type after applying the - operator.

fn sub(self, rhs: I) -> Self

Performs the - operation.

impl<T: AxisDimension, I: Into<AxisDiff<T>>> SubAssign<I> for AxisDiff<T>

fn sub_assign(&mut self, rhs: I)

Performs the -= operation.

impl<'a, T: 'a + AxisDimension + PartialOrd + Ord> Sum<&'a AxisDiff<T>> for AxisDiff<T>

fn sum<I>(iter: I) -> Self

where I: Iterator<Item = &'a Self>,

Takes an iterator and generates Self from the elements by “summing up” the items.

impl<T: AxisDimension + PartialOrd + Ord> Sum for AxisDiff<T>

fn sum<I>(iter: I) -> Self

where I: Iterator<Item = Self>,

Takes an iterator and generates Self from the elements by “summing up” the items.

impl<T: Copy + AxisDimension> Copy for AxisDiff<T>

impl<T: Eq + AxisDimension> Eq for AxisDiff<T>