Struct vsvg::Length

pub struct Length {
    pub value: f64,
    pub unit: Unit,
}

A physical length, described by a value and a Unit.

A Length can be created with Length::new, by multiplying a float with a Unit, or using the shorthand constructors:

assert_eq!(Length::new(0.0356, Unit::Cm), 0.0356 * Unit::Cm);
assert_eq!(Length::new(0.0356, Unit::Cm), Length::cm(0.0356));

All float conversion assume the default Unit of Unit::Px:

assert_eq!(Length::from(96.0), Length::new(96., Unit::Px));
assert_eq!(f64::from(1.0 * Unit::In), 96.0);

The usual arithmetic operations are supported.

Note: Floats are always considered as Unit::Px. When adding or subtracting two Lengths, the result will have the Unit of the left-hand side.

// Negation is supported.
assert_eq!(-Length::new(1.0, Unit::In), -1.0 * Unit::In);

// The result has the unit of the left-hand side.
assert_eq!(1.0 * Unit::In + 2.54 * Unit::Cm, 2.0 * Unit::In);
assert_eq!(5.08 * Unit::Cm - 1.0 * Unit::In, 2.54 * Unit::Cm);

// Floats are considered pixels.
assert_eq!(1.0 * Unit::In + 96.0, 2.0 * Unit::In);
assert_eq!(96.0 + 1.0 * Unit::In , 2.0 * Unit::In);
assert_eq!(2.0 * Unit::In - 96.0, 1.0 * Unit::In);
assert_eq!(96.0 - 0.5 * Unit::In, 0.5 * Unit::In);

// Multiplication and division by floats is supported.
// Note: dividing by a `Length` is not supported.
assert_eq!((1.0 * Unit::In) * 2.0, 2.0 * Unit::In);
assert_eq!(2.0 * (1.0 * Unit::In), 2.0 * Unit::In);
assert_eq!((1.0 * Unit::In) / 2.0, 0.5 * Unit::In);

Length implements From for Unit, so you can use Unit as a shorthand:

assert_eq!(Length::from(Unit::In), Length::new(1., Unit::In));

A Length with a different Unit can be converted using Length::convert_to:

let l = Length::new(2.54, Unit::Cm);
assert_eq!(l.convert_to(Unit::In), 1.0 * Unit::In);

Length delegates Display to f64, so it supports the standard float formatting syntax:

let l = Length::new(0.0356, vsvg::Unit::Cm);
assert_eq!(format!("{l:.2}"), "0.04cm");

Fields

value: f64

unit: Unit

Implementations

impl Length

pub fn new<F: Float + AsPrimitive<f64>>(value: F, unit: Unit) -> Self

Create a Length with the given value and Unit.

pub fn pixels<F: Float + AsPrimitive<f64>>(value: F) -> Self

Create a Length with the given value and a Unit::Px unit.

pub fn inches<F: Float + AsPrimitive<f64>>(value: F) -> Self

Create a Length with the given value and a Unit::In unit.

pub fn feet<F: Float + AsPrimitive<f64>>(value: F) -> Self

Create a Length with the given value and a Unit::Ft unit.

pub fn yards<F: Float + AsPrimitive<f64>>(value: F) -> Self

Create a Length with the given value and a Unit::Yd unit.

pub fn miles<F: Float + AsPrimitive<f64>>(value: F) -> Self

Create a Length with the given value and a Unit::Mi unit.

pub fn mm<F: Float + AsPrimitive<f64>>(value: F) -> Self

Create a Length with the given value and a Unit::Mm unit.

pub fn cm<F: Float + AsPrimitive<f64>>(value: F) -> Self

Create a Length with the given value and a Unit::Cm unit.

pub fn meters<F: Float + AsPrimitive<f64>>(value: F) -> Self

Create a Length with the given value and a Unit::M unit.

pub fn km<F: Float + AsPrimitive<f64>>(value: F) -> Self

Create a Length with the given value and a Unit::Km unit.

pub fn picas<F: Float + AsPrimitive<f64>>(value: F) -> Self

Create a Length with the given value and a Unit::Pc unit.

pub fn points<F: Float + AsPrimitive<f64>>(value: F) -> Self

Create a Length with the given value and a Unit::Pt unit.

pub fn to_px<F: Float>(&self) -> F

Convert the Length to a float, assuming the default Unit of Unit::Px.

pub fn convert_to(self, unit: Unit) -> Self

Convert the Length to another Length with the given Unit.

Trait Implementations

impl<F: Float + AsPrimitive<f64>> Add<F> for Length

type Output = Length

The resulting type after applying the + operator.

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

Performs the + operation.

impl Add<Length> for f32

type Output = Length

The resulting type after applying the + operator.

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

Performs the + operation.

impl Add<Length> for f64

type Output = Length

The resulting type after applying the + operator.

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

Performs the + operation.

impl Add for Length

type Output = Length

The resulting type after applying the + operator.

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

Performs the + operation.

impl Clone for Length

fn clone(&self) -> Length

Returns a copy of the value.

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

Performs copy-assignment from source.

impl Debug for Length

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

Formats the value using the given formatter.

impl Default for Length

fn default() -> Self

Returns the “default value” for a type.

impl<'de> Deserialize<'de> for Length

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

where __D: Deserializer<'de>,

Deserialize this value from the given Serde deserializer.

impl Display for Length

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

Formats the value using the given formatter.

impl<F: Float + AsPrimitive<f64>> Div<F> for Length

type Output = Length

The resulting type after applying the / operator.

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

Performs the / operation.

impl From<&Length> for f32

fn from(length: &Length) -> Self

Converts to this type from the input type.

impl From<&Length> for f64

fn from(length: &Length) -> Self

Converts to this type from the input type.

impl From<&Unit> for Length

fn from(value: &Unit) -> Self

Converts to this type from the input type.

impl<F: Float + AsPrimitive<f64>> From<F> for Length

fn from(value: F) -> Self

Converts to this type from the input type.

impl From<Length> for f32

fn from(length: Length) -> Self

Converts to this type from the input type.

impl From<Length> for f64

fn from(length: Length) -> Self

Converts to this type from the input type.

impl From<Unit> for Length

fn from(value: Unit) -> Self

Converts to this type from the input type.

impl<F: Float + AsPrimitive<f64>> Mul<F> for Length

type Output = Length

The resulting type after applying the * operator.

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

Performs the * operation.

impl Mul<Length> for f32

type Output = Length

The resulting type after applying the * operator.

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

Performs the * operation.

impl Mul<Length> for f64

type Output = Length

The resulting type after applying the * operator.

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

Performs the * operation.

impl Neg for Length

type Output = Length

The resulting type after applying the - operator.

fn neg(self) -> Self::Output

Performs the unary - operation.

impl PartialEq for Length

fn eq(&self, other: &Length) -> 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 Serialize for Length

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

where __S: Serializer,

Serialize this value into the given Serde serializer.

impl<F: Float + AsPrimitive<f64>> Sub<F> for Length

type Output = Length

The resulting type after applying the - operator.

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

Performs the - operation.

impl Sub<Length> for f32

type Output = Length

The resulting type after applying the - operator.

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

Performs the - operation.

impl Sub<Length> for f64

type Output = Length

The resulting type after applying the - operator.

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

Performs the - operation.

impl Sub for Length

type Output = Length

The resulting type after applying the - operator.

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

Performs the - operation.

impl Copy for Length

impl StructuralPartialEq for Length