Struct CoordPair

pub struct CoordPair<C> {
    pub y: C,
    pub x: C,
}

Fields

y: C

x: C

Implementations

impl<C> CoordPair<C>

pub fn with_order(first: C, second: C) -> Self

pub fn from_axes<F>(generator: F) -> Self

where F: FnMut(Axis) -> C,

pub fn try_from_axes<F, E>(generator: F) -> Result<Self, E>

where F: FnMut(Axis) -> Result<C, E>,

pub fn into_order(self) -> (C, C)

pub fn as_ref(&self) -> CoordPair<&C>

pub fn as_mut(&mut self) -> CoordPair<&mut C>

pub fn map<F, C0>(self, mapper: F) -> CoordPair<C0>

where F: FnMut(C) -> C0,

pub fn try_map<F, C0, E>(self, mapper: F) -> Result<CoordPair<C0>, E>

where F: FnMut(C) -> Result<C0, E>,

pub fn map_with_axes<F, C0>(self, mapper: F) -> CoordPair<C0>

where F: FnMut(C, Axis) -> C0,

pub fn try_map_with_axes<F, C0, E>(self, mapper: F) -> Result<CoordPair<C0>, E>

where F: FnMut(C, Axis) -> Result<C0, E>,

pub fn shift(self) -> Self

pub fn shift_rev(self) -> Self

pub fn shift_in_place(&mut self)

pub fn shift_rev_in_place(&mut self)

pub fn shift_to(self, axis: Axis) -> Self

pub fn shift_in_place_to(&mut self, axis: Axis)

pub fn shift_rev_to(self, axis: Axis) -> Self

pub fn shift_rev_in_place_to(&mut self, axis: Axis)

pub fn zip2<C0>(self, other: CoordPair<C0>) -> CoordPair<(C, C0)>

pub fn zip2_with<F, C0, C1>( self, other: CoordPair<C0>, zipper: F, ) -> CoordPair<C1>

where F: FnMut(C, C0) -> C1,

pub fn zip2_with_axes<F, C0, C1>( self, other: CoordPair<C0>, zipper: F, ) -> CoordPair<C1>

where F: FnMut(C, C0, Axis) -> C1,

pub fn try_zip2_with<F, C0, C1, E>( self, other: CoordPair<C0>, zipper: F, ) -> Result<CoordPair<C1>, E>

where F: FnMut(C, C0) -> Result<C1, E>,

pub fn try_zip2_with_axes<F, C0, C1, E>( self, other: CoordPair<C0>, zipper: F, ) -> Result<CoordPair<C1>, E>

where F: FnMut(C, C0, Axis) -> Result<C1, E>,

pub fn zip3<C0, C1>( self, other: CoordPair<C0>, another: CoordPair<C1>, ) -> CoordPair<(C, C0, C1)>

pub fn zip3_with<F, C0, C1, C2>( self, other: CoordPair<C0>, another: CoordPair<C1>, zipper: F, ) -> CoordPair<C2>

where F: FnMut(C, C0, C1) -> C2,

pub fn zip3_with_axes<F, C0, C1, C2>( self, other: CoordPair<C0>, another: CoordPair<C1>, zipper: F, ) -> CoordPair<C2>

where F: FnMut(C, C0, C1, Axis) -> C2,

pub fn try_zip3_with<F, C0, C1, C2, E>( self, other: CoordPair<C0>, another: CoordPair<C1>, zipper: F, ) -> Result<CoordPair<C2>, E>

where F: FnMut(C, C0, C1) -> Result<C2, E>,

pub fn try_zip3_with_axes<F, C0, C1, C2, E>( self, other: CoordPair<C0>, another: CoordPair<C1>, zipper: F, ) -> Result<CoordPair<C2>, E>

where F: FnMut(C, C0, C1, Axis) -> Result<C2, E>,

pub fn extract(self, axis: Axis) -> C

pub fn all<F>(self, predicate: F) -> bool

where F: FnMut(C) -> bool,

pub fn any<F>(self, predicate: F) -> bool

where F: FnMut(C) -> bool,

pub fn checked_add_to(&self, other: &C) -> Option<Self>

where C: CheckedAdd,

pub fn checked_sub_except(&self, other: &C) -> Option<Self>

where C: CheckedSub,

pub fn checked_sub_from(&self, other: &C) -> Option<Self>

where C: CheckedSub,

pub fn checked_mul_scalar(&self, other: &C) -> Option<Self>

where C: CheckedMul,

pub fn checked_div_by(&self, other: &C) -> Option<Self>

where C: CheckedDiv,

pub fn checked_div_on(&self, other: &C) -> Option<Self>

where C: CheckedDiv,

pub fn checked_rem_by(&self, other: &C) -> Option<Self>

where C: CheckedRem,

pub fn checked_rem_on(&self, other: &C) -> Option<Self>

where C: CheckedRem,

pub fn saturating_add_to(&self, other: &C) -> Self

where C: SaturatingAdd,

pub fn saturating_sub_except(&self, other: &C) -> Self

where C: SaturatingSub,

pub fn saturating_sub_from(&self, other: &C) -> Self

where C: SaturatingSub,

pub fn saturating_mul_scalar(&self, other: &C) -> Self

where C: SaturatingMul,

pub fn div_floor_by(&self, divisor: &C) -> Self

where C: Integer,

pub fn div_ceil_by(&self, divisor: &C) -> Self

where C: Integer,

pub fn div_floor_on(&self, dividend: &C) -> Self

where C: Integer,

pub fn div_ceil_on(&self, dividend: &C) -> Self

where C: Integer,

pub fn div_floor(&self, other: &Self) -> Self

where C: Integer,

pub fn div_ceil(&self, other: &Self) -> Self

where C: Integer,

pub fn move_unit(self, direction: Direction) -> Self

where C: Add<Output = C> + Sub<Output = C> + One,

pub fn checked_move_unit(&self, direction: Direction) -> Option<Self>

where C: CheckedAdd + CheckedSub + One + Clone,

pub fn saturating_move_unit(&self, direction: Direction) -> Self

where C: SaturatingAdd + SaturatingSub + One + Clone,

pub fn move_by(self, vector: DirectionVec<C>) -> Self

where C: Add<Output = C> + Sub<Output = C>,

pub fn checked_move_by(&self, vector: DirectionVec<&C>) -> Option<Self>

where C: CheckedAdd + CheckedSub + Clone,

pub fn saturating_move_by(&self, vector: DirectionVec<&C>) -> Self

where C: SaturatingAdd + SaturatingSub + Clone,

pub fn as_rect_size(self, top_left: Self) -> Rect<C>

pub fn as_rect_top_left(self, size: Self) -> Rect<C>

pub fn direction_to(self, other: Self) -> Option<DirectionVec<C>>

where C: PartialOrd + Sub<Output = C>,

pub fn direction_from(self, other: Self) -> Option<DirectionVec<C>>

where C: PartialOrd + Sub<Output = C>,

impl<'a, C> CoordPair<&'a C>

pub fn copied(self) -> CoordPair<C>

where C: Copy,

pub fn cloned(self) -> CoordPair<C>

where C: Clone,

pub fn checked_add_by_ref(self, other: Self) -> Option<CoordPair<C>>

where C: CheckedAdd,

pub fn checked_add_by_ref_to(self, other: &C) -> Option<CoordPair<C>>

where C: CheckedAdd,

pub fn checked_sub_by_ref(self, other: Self) -> Option<CoordPair<C>>

where C: CheckedSub,

pub fn checked_sub_by_ref_except(self, other: &C) -> Option<CoordPair<C>>

where C: CheckedSub,

pub fn checked_sub_by_ref_from(self, other: &C) -> Option<CoordPair<C>>

where C: CheckedSub,

pub fn checked_mul_by_ref(self, other: Self) -> Option<CoordPair<C>>

where C: CheckedMul,

pub fn checked_mul_by_ref_scalar(self, other: &C) -> Option<CoordPair<C>>

where C: CheckedMul,

pub fn checked_div_by_ref(self, other: Self) -> Option<CoordPair<C>>

where C: CheckedDiv,

pub fn checked_div_by_ref_by(self, other: &C) -> Option<CoordPair<C>>

where C: CheckedDiv,

pub fn checked_div_by_ref_on(self, other: &C) -> Option<CoordPair<C>>

where C: CheckedDiv,

pub fn checked_rem_by_ref(self, other: Self) -> Option<CoordPair<C>>

where C: CheckedRem,

pub fn checked_rem_by_ref_by(self, other: &C) -> Option<CoordPair<C>>

where C: CheckedRem,

pub fn checked_rem_by_ref_on(self, other: &C) -> Option<CoordPair<C>>

where C: CheckedRem,

pub fn saturating_add_by_ref(self, other: Self) -> CoordPair<C>

where C: SaturatingAdd,

pub fn saturating_add_by_ref_to(self, other: &C) -> CoordPair<C>

where C: SaturatingAdd,

pub fn saturating_sub_by_ref(self, other: Self) -> CoordPair<C>

where C: SaturatingSub,

pub fn saturating_sub_by_ref_except(self, other: &C) -> CoordPair<C>

where C: SaturatingSub,

pub fn saturating_sub_by_ref_from(self, other: &C) -> CoordPair<C>

where C: SaturatingSub,

pub fn saturating_mul_by_ref(self, other: Self) -> CoordPair<C>

where C: SaturatingMul,

pub fn saturating_mul_by_ref_scalar(self, other: &C) -> CoordPair<C>

where C: SaturatingMul,

pub fn div_floor_by_ref_by(self, divisor: &C) -> CoordPair<C>

where C: Integer,

pub fn div_ceil_by_ref_by(self, divisor: &C) -> CoordPair<C>

where C: Integer,

pub fn div_floor_by_ref_on(self, dividend: &C) -> CoordPair<C>

where C: Integer,

pub fn div_ceil_by_ref_on(self, dividend: &C) -> CoordPair<C>

where C: Integer,

pub fn div_floor_by_ref(self, other: Self) -> CoordPair<C>

where C: Integer,

pub fn div_ceil_by_ref(self, other: Self) -> CoordPair<C>

where C: Integer,

pub fn checked_move_unit_by_ref( self, direction: Direction, ) -> Option<CoordPair<C>>

where C: CheckedAdd + CheckedSub + One + Clone,

pub fn saturating_move_unit_by_ref(self, direction: Direction) -> CoordPair<C>

where C: SaturatingAdd + SaturatingSub + One + Clone,

pub fn checked_move_by_ref_by( self, vector: DirectionVec<&C>, ) -> Option<CoordPair<C>>

where C: CheckedAdd + CheckedSub + Clone,

pub fn saturating_move_by_ref_by(self, vector: DirectionVec<&C>) -> CoordPair<C>

where C: SaturatingAdd + SaturatingSub + Clone,

impl<'a, C> CoordPair<&'a mut C>

pub fn copied(self) -> CoordPair<C>

where C: Copy,

pub fn cloned(self) -> CoordPair<C>

where C: Clone,

pub fn share(self) -> CoordPair<&'a C>

impl<C> CoordPair<Option<C>>

pub fn transpose(self) -> Option<CoordPair<C>>

pub fn from_transposed(transposed: Option<CoordPair<C>>) -> Self

impl<C, E> CoordPair<Result<C, E>>

pub fn transpose(self) -> Result<CoordPair<C>, E>

pub fn from_transposed(transposed: Result<CoordPair<C>, E>) -> Self

where E: Clone,

Trait Implementations

impl<C> Add<C> for CoordPair<C>

where C: Add + Clone,

type Output = CoordPair<<C as Add>::Output>

The resulting type after applying the + operator.

fn add(self, rhs: C) -> Self::Output

Performs the + operation.

impl<C> Add for CoordPair<C>

where C: Add,

type Output = CoordPair<<C as Add>::Output>

The resulting type after applying the + operator.

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

Performs the + operation.

impl<C> AddAssign<C> for CoordPair<C>

where C: AddAssign + Clone,

fn add_assign(&mut self, rhs: C)

Performs the += operation.

impl<C> AddAssign for CoordPair<C>

where C: AddAssign,

fn add_assign(&mut self, rhs: Self)

Performs the += operation.

impl<C> CheckedAdd for CoordPair<C>

where C: CheckedAdd,

fn checked_add(&self, other: &Self) -> Option<Self>

Adds two numbers, checking for overflow. If overflow happens, None is returned.

impl<C> CheckedDiv for CoordPair<C>

where C: CheckedDiv,

fn checked_div(&self, other: &Self) -> Option<Self>

Divides two numbers, checking for underflow, overflow and division by zero. If any of that happens, None is returned.

impl<C> CheckedMul for CoordPair<C>

where C: CheckedMul,

fn checked_mul(&self, other: &Self) -> Option<Self>

Multiplies two numbers, checking for underflow or overflow. If underflow or overflow happens, None is returned.

impl<C> CheckedRem for CoordPair<C>

where C: CheckedRem,

fn checked_rem(&self, other: &Self) -> Option<Self>

Finds the remainder of dividing two numbers, checking for underflow, overflow and division by zero. If any of that happens, None is returned.

impl<C> CheckedSub for CoordPair<C>

where C: CheckedSub,

fn checked_sub(&self, other: &Self) -> Option<Self>

Subtracts two numbers, checking for underflow. If underflow happens, None is returned.

impl<C: Clone> Clone for CoordPair<C>

fn clone(&self) -> CoordPair<C>

Returns a copy of the value.

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

Performs copy-assignment from source.

impl<C: Debug> Debug for CoordPair<C>

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

Formats the value using the given formatter.

impl<C: Default> Default for CoordPair<C>

fn default() -> CoordPair<C>

Returns the “default value” for a type.

impl<'de, C> Deserialize<'de> for CoordPair<C>

where C: Deserialize<'de>,

fn deserialize<__D>(__deserializer: __D) -> Result<Self, __D::Error>

where __D: Deserializer<'de>,

Deserialize this value from the given Serde deserializer.

impl<C> Display for CoordPair<C>

where C: Display,

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

Formats the value using the given formatter.

impl<C> Div<C> for CoordPair<C>

where C: Div + Clone,

type Output = CoordPair<<C as Div>::Output>

The resulting type after applying the / operator.

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

Performs the / operation.

impl<C> Div for CoordPair<C>

where C: Div,

type Output = CoordPair<<C as Div>::Output>

The resulting type after applying the / operator.

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

Performs the / operation.

impl<C> DivAssign<C> for CoordPair<C>

where C: DivAssign + Clone,

fn div_assign(&mut self, rhs: C)

Performs the /= operation.

impl<C> DivAssign for CoordPair<C>

where C: DivAssign,

fn div_assign(&mut self, rhs: Self)

Performs the /= operation.

impl<C: Hash> Hash for CoordPair<C>

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, Self: Sized,

Feeds a slice of this type into the given Hasher.

impl<C> Index<Axis> for CoordPair<C>

type Output = C

The returned type after indexing.

fn index(&self, index: Axis) -> &Self::Output

Performs the indexing (container[index]) operation.

impl<T> Index<CoordPair<Order>> for DiagonalMap<T>

type Output = T

The returned type after indexing.

fn index(&self, index: CoordPair<Order>) -> &Self::Output

Performs the indexing (container[index]) operation.

impl<C> IndexMut<Axis> for CoordPair<C>

fn index_mut(&mut self, index: Axis) -> &mut Self::Output

Performs the mutable indexing (container[index]) operation.

impl<T> IndexMut<CoordPair<Order>> for DiagonalMap<T>

fn index_mut(&mut self, index: CoordPair<Order>) -> &mut Self::Output

Performs the mutable indexing (container[index]) operation.

impl<C> Mul<C> for CoordPair<C>

where C: Mul + Clone,

type Output = CoordPair<<C as Mul>::Output>

The resulting type after applying the * operator.

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

Performs the * operation.

impl<C> Mul for CoordPair<C>

where C: Mul,

type Output = CoordPair<<C as Mul>::Output>

The resulting type after applying the * operator.

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

Performs the * operation.

impl<C> MulAssign<C> for CoordPair<C>

where C: MulAssign + Clone,

fn mul_assign(&mut self, rhs: C)

Performs the *= operation.

impl<C> MulAssign for CoordPair<C>

where C: MulAssign,

fn mul_assign(&mut self, rhs: Self)

Performs the *= operation.

impl<C> Neg for CoordPair<C>

where C: Neg,

type Output = CoordPair<<C as Neg>::Output>

The resulting type after applying the - operator.

fn neg(self) -> Self::Output

Performs the unary - operation.

impl<C> One for CoordPair<C>

where C: One,

fn one() -> Self

Returns the multiplicative identity element of Self, 1.

fn set_one(&mut self)

Sets self to the multiplicative identity element of Self, 1.

fn is_one(&self) -> bool

where Self: PartialEq,

Returns true if self is equal to the multiplicative identity.

impl<C: Ord> Ord for CoordPair<C>

fn cmp(&self, other: &CoordPair<C>) -> 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<C: PartialEq> PartialEq for CoordPair<C>

fn eq(&self, other: &CoordPair<C>) -> bool

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

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<C: PartialOrd> PartialOrd for CoordPair<C>

fn partial_cmp(&self, other: &CoordPair<C>) -> 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<C> Rem<C> for CoordPair<C>

where C: Rem + Clone,

type Output = CoordPair<<C as Rem>::Output>

The resulting type after applying the % operator.

fn rem(self, rhs: C) -> Self::Output

Performs the % operation.

impl<C> Rem for CoordPair<C>

where C: Rem,

type Output = CoordPair<<C as Rem>::Output>

The resulting type after applying the % operator.

fn rem(self, rhs: Self) -> Self::Output

Performs the % operation.

impl<C> RemAssign<C> for CoordPair<C>

where C: RemAssign + Clone,

fn rem_assign(&mut self, rhs: C)

Performs the %= operation.

impl<C> RemAssign for CoordPair<C>

where C: RemAssign,

fn rem_assign(&mut self, rhs: Self)

Performs the %= operation.

impl<C> SaturatingAdd for CoordPair<C>

where C: SaturatingAdd,

fn saturating_add(&self, other: &Self) -> Self

Saturating addition. Computes self + other, saturating at the relevant high or low boundary of the type.

impl<C> SaturatingMul for CoordPair<C>

where C: SaturatingMul,

fn saturating_mul(&self, other: &Self) -> Self

Saturating multiplication. Computes self * other, saturating at the relevant high or low boundary of the type.

impl<C> SaturatingSub for CoordPair<C>

where C: SaturatingSub,

fn saturating_sub(&self, other: &Self) -> Self

Saturating subtraction. Computes self - other, saturating at the relevant high or low boundary of the type.

impl<C> Serialize for CoordPair<C>

where C: Serialize,

fn serialize<__S>(&self, __serializer: __S) -> Result<__S::Ok, __S::Error>

where __S: Serializer,

Serialize this value into the given Serde serializer.

impl<C> Sub<C> for CoordPair<C>

where C: Sub + Clone,

type Output = CoordPair<<C as Sub>::Output>

The resulting type after applying the - operator.

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

Performs the - operation.

impl<C> Sub for CoordPair<C>

where C: Sub,

type Output = CoordPair<<C as Sub>::Output>

The resulting type after applying the - operator.

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

Performs the - operation.

impl<C> SubAssign<C> for CoordPair<C>

where C: SubAssign + Clone,

fn sub_assign(&mut self, rhs: C)

Performs the -= operation.

impl<C> SubAssign for CoordPair<C>

where C: SubAssign,

fn sub_assign(&mut self, rhs: Self)

Performs the -= operation.

impl<C> Zero for CoordPair<C>

where C: Zero + PartialEq,

fn zero() -> Self

Returns the additive identity element of Self, 0.

fn is_zero(&self) -> bool

Returns true if self is equal to the additive identity.

fn set_zero(&mut self)

Sets self to the additive identity element of Self, 0.

impl<C: Copy> Copy for CoordPair<C>

impl<C: Eq> Eq for CoordPair<C>

impl<C> StructuralPartialEq for CoordPair<C>