Struct figures::Size

pub struct Size<Unit> {
    pub width: Unit,
    pub height: Unit,
}

A width and a height measurement.

Fields

width: Unit

The width component

height: Unit

The height component

Implementations

impl<Unit> Size<Unit>

pub const fn new(width: Unit, height: Unit) -> Self

Returns a new size of the given width and height.

pub fn squared(dimension: Unit) -> Selfwhere Unit: Clone,

Returns a new size using dimension for both width and height.

pub fn area(&self) -> <Unit as Mul>::Outputwhere Unit: Mul + Copy,

Returns the area of the rectangle.

pub fn cast<NewUnit>(self) -> Size<NewUnit>where NewUnit: From<Unit>,

Converts the contents of this size to NewUnit using From.

pub fn map<NewUnit>(self, map: impl FnMut(Unit) -> NewUnit) -> Size<NewUnit>

Maps each component to map and returns a new value with the mapped components.

pub fn try_cast<NewUnit>(self) -> Result<Size<NewUnit>, NewUnit::Error>where NewUnit: TryFrom<Unit>,

Converts the contents of this size to NewUnit using TryFrom.

Errors

Returns <NewUnit as TryFrom>::Error when the inner type cannot be converted. For this crate’s types, this genenerally will be

Trait Implementations

impl<Unit> Abs for Size<Unit>where Unit: Abs,

fn abs(&self) -> Self

Returns the positive difference between this value and 0.

impl<Unit> Add<Lp> for Size<Unit>where Unit: Add<Lp, Output = Unit>,

type Output = Size<Unit>

The resulting type after applying the + operator.

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

Performs the + operation.

impl<T, Unit> Add<Point<T>> for Size<Unit>where Unit: Add<T, Output = Unit>,

type Output = Size<Unit>

The resulting type after applying the + operator.

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

Performs the + operation.

impl<Unit> Add<Px> for Size<Unit>where Unit: Add<Px, Output = Unit>,

type Output = Size<Unit>

The resulting type after applying the + operator.

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

Performs the + operation.

impl<T, Unit> Add<Size<T>> for Point<Unit>where Unit: Add<T, Output = Unit>,

type Output = Point<Unit>

The resulting type after applying the + operator.

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

Performs the + operation.

impl<T, Unit> Add<Size<T>> for Size<Unit>where Unit: Add<T, Output = Unit>,

type Output = Size<Unit>

The resulting type after applying the + operator.

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

Performs the + operation.

impl<Unit> Add<UPx> for Size<Unit>where Unit: Add<UPx, Output = Unit>,

type Output = Size<Unit>

The resulting type after applying the + operator.

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

Performs the + operation.

impl<Unit> Add<f32> for Size<Unit>where Unit: Add<f32, Output = Unit>,

type Output = Size<Unit>

The resulting type after applying the + operator.

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

Performs the + operation.

impl<Unit> Add<i32> for Size<Unit>where Unit: Add<i32, Output = Unit>,

type Output = Size<Unit>

The resulting type after applying the + operator.

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

Performs the + operation.

impl<Unit> Add<u32> for Size<Unit>where Unit: Add<u32, Output = Unit>,

type Output = Size<Unit>

The resulting type after applying the + operator.

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

Performs the + operation.

impl<Unit> AddAssign<Point<Unit>> for Size<Unit>where Unit: AddAssign,

fn add_assign(&mut self, rhs: Point<Unit>)

Performs the += operation.

impl<Unit> AddAssign<Size<Unit>> for Point<Unit>where Unit: AddAssign,

fn add_assign(&mut self, rhs: Size<Unit>)

Performs the += operation.

impl<Unit> AddAssign<Unit> for Size<Unit>where Unit: AddAssign + Clone,

fn add_assign(&mut self, rhs: Unit)

Performs the += operation.

impl<Unit> AddAssign for Size<Unit>where Unit: AddAssign,

fn add_assign(&mut self, rhs: Size<Unit>)

Performs the += operation.

impl<Unit: Clone> Clone for Size<Unit>

fn clone(&self) -> Size<Unit>

Returns a copy of the value.

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

Performs copy-assignment from source.

impl<Unit: Debug> Debug for Size<Unit>

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

Formats the value using the given formatter.

impl<Unit: Default> Default for Size<Unit>

fn default() -> Size<Unit>

Returns the “default value” for a type.

impl<'de, Unit> Deserialize<'de> for Size<Unit>where Unit: Deserialize<'de>,

fn deserialize<__D>(__deserializer: __D) -> Result<Self, __D::Error>where __D: Deserializer<'de>,

Deserialize this value from the given Serde deserializer.

impl<Unit> Div<Lp> for Size<Unit>where Unit: Div<Lp, Output = Unit>,

type Output = Size<Unit>

The resulting type after applying the / operator.

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

Performs the / operation.

impl<T, Unit> Div<Point<T>> for Size<Unit>where Unit: Div<T, Output = Unit>,

type Output = Size<Unit>

The resulting type after applying the / operator.

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

Performs the / operation.

impl<Unit> Div<Px> for Size<Unit>where Unit: Div<Px, Output = Unit>,

type Output = Size<Unit>

The resulting type after applying the / operator.

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

Performs the / operation.

impl<T, Unit> Div<Size<T>> for Point<Unit>where Unit: Div<T, Output = Unit>,

type Output = Point<Unit>

The resulting type after applying the / operator.

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

Performs the / operation.

impl<T, Unit> Div<Size<T>> for Size<Unit>where Unit: Div<T, Output = Unit>,

type Output = Size<Unit>

The resulting type after applying the / operator.

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

Performs the / operation.

impl<Unit> Div<UPx> for Size<Unit>where Unit: Div<UPx, Output = Unit>,

type Output = Size<Unit>

The resulting type after applying the / operator.

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

Performs the / operation.

impl<Unit> Div<f32> for Size<Unit>where Unit: Div<f32, Output = Unit>,

type Output = Size<Unit>

The resulting type after applying the / operator.

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

Performs the / operation.

impl<Unit> Div<i32> for Size<Unit>where Unit: Div<i32, Output = Unit>,

type Output = Size<Unit>

The resulting type after applying the / operator.

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

Performs the / operation.

impl<Unit> Div<u32> for Size<Unit>where Unit: Div<u32, Output = Unit>,

type Output = Size<Unit>

The resulting type after applying the / operator.

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

Performs the / operation.

impl<Unit> DivAssign<Point<Unit>> for Size<Unit>where Unit: DivAssign,

fn div_assign(&mut self, rhs: Point<Unit>)

Performs the /= operation.

impl<Unit> DivAssign<Size<Unit>> for Point<Unit>where Unit: DivAssign,

fn div_assign(&mut self, rhs: Size<Unit>)

Performs the /= operation.

impl<Unit> DivAssign<Unit> for Size<Unit>where Unit: DivAssign + Clone,

fn div_assign(&mut self, rhs: Unit)

Performs the /= operation.

impl<Unit> DivAssign for Size<Unit>where Unit: DivAssign,

fn div_assign(&mut self, rhs: Size<Unit>)

Performs the /= operation.

impl<T> FloatConversion for Size<T>where T: FloatConversion,

type Float = Size<<T as FloatConversion>::Float>

The type that represents this type in floating point form.

fn into_float(self) -> Self::Float

Returns this value in floating point form.

fn from_float(float: Self::Float) -> Self

Converts from floating point to this form.

impl From<PhysicalSize<i32>> for Size<Px>

fn from(value: PhysicalSize<i32>) -> Self

Converts to this type from the input type.

impl From<PhysicalSize<u32>> for Size<UPx>

fn from(value: PhysicalSize<u32>) -> Self

Converts to this type from the input type.

impl<Unit> From<Point<Unit>> for Size<Unit>

fn from(value: Point<Unit>) -> Self

Converts to this type from the input type.

impl From<Size<Px>> for PhysicalSize<i32>

fn from(size: Size<Px>) -> Self

Converts to this type from the input type.

impl From<Size<UPx>> for Extent3d

fn from(value: Size<UPx>) -> Self

Converts to this type from the input type.

impl From<Size<UPx>> for PhysicalSize<u32>

fn from(size: Size<UPx>) -> Self

Converts to this type from the input type.

impl<Unit> From<Size<Unit>> for Point<Unit>

fn from(value: Size<Unit>) -> Self

Converts to this type from the input type.

impl<Unit> From<Size<Unit>> for Rect<Unit>where Unit: Default,

fn from(size: Size<Unit>) -> Self

Converts to this type from the input type.

impl<Unit> FromComponents<Unit> for Size<Unit>

fn from_components(components: (Unit, Unit)) -> Self

Returns a new instance from the 2d vector components provided.

fn from_vec<Type>(other: Type) -> Selfwhere Type: IntoComponents<Unit>,

Converts this type to another type using FromComponents and IntoComponents.

impl<Unit: Hash> Hash for Size<Unit>

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<Unit> IntoComponents<Unit> for Size<Unit>

fn into_components(self) -> (Unit, Unit)

Extracts this type’s 2d vector components.

fn to_vec<Type>(self) -> Typewhere Type: FromComponents<Unit>,

Converts this type to another type using FromComponents and IntoComponents.

impl<Unit> IntoSigned for Size<Unit>where Unit: IntoSigned,

type Signed = Size<<Unit as IntoSigned>::Signed>

The signed representation of this type.

fn into_signed(self) -> Self::Signed

Returns this value as an unsigned value. Values that are larger than can fit in an i32 are converted to i32::MAX.

impl<Unit> IntoUnsigned for Size<Unit>where Unit: IntoUnsigned,

type Unsigned = Size<<Unit as IntoUnsigned>::Unsigned>

The unsigned representation of this type.

fn into_unsigned(self) -> Self::Unsigned

Returns this value as an unsigned value. Negative values will be converted to 0.

impl<Unit> Mul<Lp> for Size<Unit>where Unit: Mul<Lp, Output = Unit>,

type Output = Size<Unit>

The resulting type after applying the * operator.

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

Performs the * operation.

impl<T, Unit> Mul<Point<T>> for Size<Unit>where Unit: Mul<T, Output = Unit>,

type Output = Size<Unit>

The resulting type after applying the * operator.

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

Performs the * operation.

impl<Unit> Mul<Px> for Size<Unit>where Unit: Mul<Px, Output = Unit>,

type Output = Size<Unit>

The resulting type after applying the * operator.

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

Performs the * operation.

impl<T, Unit> Mul<Size<T>> for Point<Unit>where Unit: Mul<T, Output = Unit>,

type Output = Point<Unit>

The resulting type after applying the * operator.

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

Performs the * operation.

impl<T, Unit> Mul<Size<T>> for Size<Unit>where Unit: Mul<T, Output = Unit>,

type Output = Size<Unit>

The resulting type after applying the * operator.

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

Performs the * operation.

impl<Unit> Mul<UPx> for Size<Unit>where Unit: Mul<UPx, Output = Unit>,

type Output = Size<Unit>

The resulting type after applying the * operator.

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

Performs the * operation.

impl<Unit> Mul<f32> for Size<Unit>where Unit: Mul<f32, Output = Unit>,

type Output = Size<Unit>

The resulting type after applying the * operator.

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

Performs the * operation.

impl<Unit> Mul<i32> for Size<Unit>where Unit: Mul<i32, Output = Unit>,

type Output = Size<Unit>

The resulting type after applying the * operator.

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

Performs the * operation.

impl<Unit> Mul<u32> for Size<Unit>where Unit: Mul<u32, Output = Unit>,

type Output = Size<Unit>

The resulting type after applying the * operator.

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

Performs the * operation.

impl<Unit> MulAssign<Point<Unit>> for Size<Unit>where Unit: MulAssign,

fn mul_assign(&mut self, rhs: Point<Unit>)

Performs the *= operation.

impl<Unit> MulAssign<Size<Unit>> for Point<Unit>where Unit: MulAssign,

fn mul_assign(&mut self, rhs: Size<Unit>)

Performs the *= operation.

impl<Unit> MulAssign<Unit> for Size<Unit>where Unit: MulAssign + Clone,

fn mul_assign(&mut self, rhs: Unit)

Performs the *= operation.

impl<Unit> MulAssign for Size<Unit>where Unit: MulAssign,

fn mul_assign(&mut self, rhs: Size<Unit>)

Performs the *= operation.

impl<Unit> Neg for Size<Unit>where Unit: Neg<Output = Unit>,

type Output = Size<Unit>

The resulting type after applying the - operator.

fn neg(self) -> Self::Output

Performs the unary - operation.

impl<Unit> Ord for Size<Unit>where Unit: Ord + Mul<Output = Unit> + Copy,

fn cmp(&self, other: &Self) -> Ordering

This method returns an Ordering between self and other.

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

Compares and returns the maximum of two values.

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

Compares and returns the minimum of two values.

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

Restrict a value to a certain interval.

impl<Unit: PartialEq> PartialEq for Size<Unit>

fn eq(&self, other: &Size<Unit>) -> bool

This method tests for self and other values to be equal, and is used by ==.

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

This method tests for !=. The default implementation is almost always sufficient, and should not be overridden without very good reason.

impl<Unit> PartialOrd for Size<Unit>where Unit: Ord + Mul<Output = Unit> + Copy,

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

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

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

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

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

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

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

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

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<Unit> Pow for Size<Unit>where Unit: Pow,

fn pow(&self, exp: u32) -> Self

Returns the saturating result of raising self to the exp power.

impl<Unit> Ranged for Size<Unit>where Unit: Ranged,

const MAX: Self = _

The maximum value for this type.

const MIN: Self = _

The minimum value for this type.

impl<Unit> Rem<Lp> for Size<Unit>where Unit: Rem<Lp, Output = Unit>,

type Output = Size<Unit>

The resulting type after applying the % operator.

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

Performs the % operation.

impl<T, Unit> Rem<Point<T>> for Size<Unit>where Unit: Rem<T, Output = Unit>,

type Output = Size<Unit>

The resulting type after applying the % operator.

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

Performs the % operation.

impl<Unit> Rem<Px> for Size<Unit>where Unit: Rem<Px, Output = Unit>,

type Output = Size<Unit>

The resulting type after applying the % operator.

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

Performs the % operation.

impl<T, Unit> Rem<Size<T>> for Point<Unit>where Unit: Rem<T, Output = Unit>,

type Output = Point<Unit>

The resulting type after applying the % operator.

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

Performs the % operation.

impl<T, Unit> Rem<Size<T>> for Size<Unit>where Unit: Rem<T, Output = Unit>,

type Output = Size<Unit>

The resulting type after applying the % operator.

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

Performs the % operation.

impl<Unit> Rem<UPx> for Size<Unit>where Unit: Rem<UPx, Output = Unit>,

type Output = Size<Unit>

The resulting type after applying the % operator.

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

Performs the % operation.

impl<Unit> Rem<f32> for Size<Unit>where Unit: Rem<f32, Output = Unit>,

type Output = Size<Unit>

The resulting type after applying the % operator.

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

Performs the % operation.

impl<Unit> Rem<i32> for Size<Unit>where Unit: Rem<i32, Output = Unit>,

type Output = Size<Unit>

The resulting type after applying the % operator.

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

Performs the % operation.

impl<Unit> Rem<u32> for Size<Unit>where Unit: Rem<u32, Output = Unit>,

type Output = Size<Unit>

The resulting type after applying the % operator.

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

Performs the % operation.

impl<Unit> RemAssign<Point<Unit>> for Size<Unit>where Unit: RemAssign,

fn rem_assign(&mut self, rhs: Point<Unit>)

Performs the %= operation.

impl<Unit> RemAssign<Size<Unit>> for Point<Unit>where Unit: RemAssign,

fn rem_assign(&mut self, rhs: Size<Unit>)

Performs the %= operation.

impl<Unit> RemAssign<Unit> for Size<Unit>where Unit: RemAssign + Clone,

fn rem_assign(&mut self, rhs: Unit)

Performs the %= operation.

impl<Unit> RemAssign for Size<Unit>where Unit: RemAssign,

fn rem_assign(&mut self, rhs: Size<Unit>)

Performs the %= operation.

impl<Unit> Round for Size<Unit>where Unit: Round,

fn round(self) -> Self

Returns self rounded to the nearest whole number.

fn ceil(self) -> Self

Returns self raised to the next whole number further away from 0.

fn floor(self) -> Self

Returns self lowered to the next whole number closer to 0.

impl<Unit> ScreenScale for Size<Unit>where Unit: ScreenScale<Lp = Lp, Px = Px, UPx = UPx>,

type Lp = Size<Lp>

This type when measuring with Lp.

type Px = Size<Px>

This type when measuring with Px.

type UPx = Size<UPx>

This type when measuring with UPx.

fn into_px(self, scale: Fraction) -> Self::Px

Converts this value from its current unit into device pixels (Px) using the provided scale factor.

fn from_px(px: Self::Px, scale: Fraction) -> Self

Converts from pixels into this type, using the provided scale factor.

fn into_lp(self, scale: Fraction) -> Self::Lp

Converts this value from its current unit into device independent pixels (Lp) using the provided scale factor.

fn from_lp(lp: Self::Lp, scale: Fraction) -> Self

Converts from Lp into this type, using the provided scale factor.

fn into_upx(self, scale: Fraction) -> Self::UPx

Converts this value from its current unit into device pixels (UPx) using the provided scale factor.

fn from_upx(px: Self::UPx, scale: Fraction) -> Self

Converts from unsigned pixels into this type, using the provided scale factor.

impl<Unit> Serialize for Size<Unit>where Unit: Serialize,

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

Serialize this value into the given Serde serializer.

impl<Unit> Sub<Lp> for Size<Unit>where Unit: Sub<Lp, Output = Unit>,

type Output = Size<Unit>

The resulting type after applying the - operator.

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

Performs the - operation.

impl<T, Unit> Sub<Point<T>> for Size<Unit>where Unit: Sub<T, Output = Unit>,

type Output = Size<Unit>

The resulting type after applying the - operator.

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

Performs the - operation.

impl<Unit> Sub<Px> for Size<Unit>where Unit: Sub<Px, Output = Unit>,

type Output = Size<Unit>

The resulting type after applying the - operator.

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

Performs the - operation.

impl<T, Unit> Sub<Size<T>> for Point<Unit>where Unit: Sub<T, Output = Unit>,

type Output = Point<Unit>

The resulting type after applying the - operator.

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

Performs the - operation.

impl<T, Unit> Sub<Size<T>> for Size<Unit>where Unit: Sub<T, Output = Unit>,

type Output = Size<Unit>

The resulting type after applying the - operator.

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

Performs the - operation.

impl<Unit> Sub<UPx> for Size<Unit>where Unit: Sub<UPx, Output = Unit>,

type Output = Size<Unit>

The resulting type after applying the - operator.

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

Performs the - operation.

impl<Unit> Sub<f32> for Size<Unit>where Unit: Sub<f32, Output = Unit>,

type Output = Size<Unit>

The resulting type after applying the - operator.

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

Performs the - operation.

impl<Unit> Sub<i32> for Size<Unit>where Unit: Sub<i32, Output = Unit>,

type Output = Size<Unit>

The resulting type after applying the - operator.

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

Performs the - operation.

impl<Unit> Sub<u32> for Size<Unit>where Unit: Sub<u32, Output = Unit>,

type Output = Size<Unit>

The resulting type after applying the - operator.

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

Performs the - operation.

impl<Unit> SubAssign<Point<Unit>> for Size<Unit>where Unit: SubAssign,

fn sub_assign(&mut self, rhs: Point<Unit>)

Performs the -= operation.

impl<Unit> SubAssign<Size<Unit>> for Point<Unit>where Unit: SubAssign,

fn sub_assign(&mut self, rhs: Size<Unit>)

Performs the -= operation.

impl<Unit> SubAssign<Unit> for Size<Unit>where Unit: SubAssign + Clone,

fn sub_assign(&mut self, rhs: Unit)

Performs the -= operation.

impl<Unit> SubAssign for Size<Unit>where Unit: SubAssign,

fn sub_assign(&mut self, rhs: Size<Unit>)

Performs the -= operation.

impl<Unit> Zero for Size<Unit>where Unit: Zero,

const ZERO: Self = _

The zero value for this type.

fn is_zero(&self) -> bool

Returns true if self represents 0.

impl Zeroable for Size<Lp>

fn zeroed() -> Self

Calls zeroed.

impl Zeroable for Size<Px>

fn zeroed() -> Self

Calls zeroed.

impl Zeroable for Size<f32>

fn zeroed() -> Self

Calls zeroed.

impl Zeroable for Size<i32>

fn zeroed() -> Self

Calls zeroed.

impl Zeroable for Size<u32>

fn zeroed() -> Self

Calls zeroed.

impl<Unit: Copy> Copy for Size<Unit>

impl<Unit: Eq> Eq for Size<Unit>

impl Pod for Size<Lp>

impl Pod for Size<Px>

impl Pod for Size<f32>

impl Pod for Size<i32>

impl Pod for Size<u32>

impl<Unit> StructuralEq for Size<Unit>

impl<Unit> StructuralPartialEq for Size<Unit>