Struct unsegen::base::basic_types::PositiveAxisDiff

pub struct PositiveAxisDiff<T: AxisDimension> { /* fields omitted */ }

PositiveAxisDiff (the base for Width or Height) specifies a non-negative (or absolute) difference between two coordinate points on a terminal grid.

Implementations

impl<T: AxisDimension> PositiveAxisDiff<T>

pub fn new_unchecked(v: i32) -> Self

Create a new PositiveAxisDiff from an i32. If v < 0 the behavior is unspecified.

Examples:

use unsegen::base::Width;
let _ = Width::new_unchecked(27); //Ok
let _ = Width::new_unchecked(0); //Ok
// let _ = Width::new_unchecked(-37); //Not allowed!

pub fn new(v: i32) -> Result<Self, ()>

Try to create a new PositiveAxisDiff from an i32. If v < 0 the behavior an error value is returned.

Examples:

use unsegen::base::Width;
assert!(Width::new(27).is_ok());
assert!(Width::new(0).is_ok());
assert!(Width::new(-37).is_err());

pub fn raw_value(self) -> i32

Unpack the PositiveAxisDiff to receive the raw i32 value.

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

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

Examples:

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

pub fn origin_range_contains(self, i: AxisIndex<T>) -> bool

Check whether the given AxisIndex is in the range [0, self)

Examples:

use unsegen::base::{ColIndex, Width};
assert!(Width::new(37).unwrap().origin_range_contains(ColIndex::new(27)));
assert!(Width::new(37).unwrap().origin_range_contains(ColIndex::new(0)));
assert!(!Width::new(27).unwrap().origin_range_contains(ColIndex::new(27)));
assert!(!Width::new(27).unwrap().origin_range_contains(ColIndex::new(37)));
assert!(!Width::new(27).unwrap().origin_range_contains(ColIndex::new(-37)));

pub fn to_signed(self) -> AxisDiff<T>

Convert the positive axis index into an AxisDiff.

Examples:

use unsegen::base::{ColDiff, Width};
assert_eq!(Width::new(37).unwrap().to_signed(), ColDiff::new(37));

Trait Implementations

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

type Output = Self

The resulting type after applying the + operator.

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

Performs the + operation.

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

fn add_assign(&mut self, rhs: I)

Performs the += operation.

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

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

Returns a copy of the value.

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

Performs copy-assignment from source.

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

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

Formats the value using the given formatter.

impl<T: AxisDimension> Div<i32> for PositiveAxisDiff<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> Div<usize> for PositiveAxisDiff<T>

type Output = Self

The resulting type after applying the / operator.

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

Performs the / operation.

impl<T: AxisDimension> From<usize> for PositiveAxisDiff<T>

fn from(v: usize) -> Self

Performs the conversion.

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

fn into(self) -> AxisDiff<T>

Performs the conversion.

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

fn into(self) -> i32

Performs the conversion.

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

fn into(self) -> usize

Performs the conversion.

impl<T: AxisDimension> Mul<i32> for PositiveAxisDiff<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> Mul<usize> for PositiveAxisDiff<T>

type Output = Self

The resulting type after applying the * operator.

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

Performs the * operation.

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

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

This method returns an Ordering between self and other.

#[must_use]

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

Compares and returns the maximum of two values.

#[must_use]

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

Compares and returns the minimum of two values.

#[must_use]

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

Restrict a value to a certain interval.

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

fn eq(&self, other: &I) -> 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<T: AxisDimension, I: Into<AxisDiff<T>> + Copy> PartialOrd<I> for PositiveAxisDiff<T>

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

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

#[must_use]

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

This method tests less than (for self and other) and is used by the < operator.

#[must_use]

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

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

#[must_use]

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

This method tests greater than (for self and other) and is used by the > operator.

#[must_use]

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

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

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

type Output = Self

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 PositiveAxisDiff<T>

type Output = AxisDiff<T>

The resulting type after applying the - operator.

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

Performs the - operation.

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

fn sum<I>(iter: I) -> Self where
    I: Iterator<Item = &'a Self>, 

Method which takes an iterator and generates Self from the elements by “summing up” the items.

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

fn sum<I>(iter: I) -> Self where
    I: Iterator<Item = Self>, 

Method which takes an iterator and generates Self from the elements by “summing up” the items.

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

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

impl<T: AxisDimension> StructuralEq for PositiveAxisDiff<T>