Struct length::Length

source ·
pub struct Length {
    pub unit: Unit,
    pub value: f64,
    /* private fields */
}

Fields§

§unit: Unit§value: f64

Implementations§

Gets a new Length struct, that represents 0 meters.

Example
use length::{Length, Unit, MetricUnit::*};

let length = Length::new();

assert_eq!(0.0, length.value);
assert_eq!(Unit::Metric(Meter), length.unit);

Gets a new Length struct with the given value and unit.

Example
use length::{Length, Unit, MetricUnit::*};

let length1 = Length::new_value_unit(1.25, Unit::Metric(Kilometer));
let length2 = Length::new_value_unit(1.25, Kilometer);

assert_eq!(1.25, length1.value);
assert_eq!(Unit::Metric(Kilometer), length1.unit);
assert_eq!(1.25, length2.value);
assert_eq!(Unit::Metric(Kilometer), length2.unit);

Gets a new Option, that represents a length by a string.

Example
use length::{Length, Unit, MetricUnit::*};

let two_meters = Length::new_string("2m").unwrap();

assert_eq!(2.0, two_meters.value);
assert_eq!(Unit::Metric(Meter), two_meters.unit);

Gets the original string of the length, if it was called with new_string(…)

Example
use length::Length;

let two_meter = Length::new_string("2m").unwrap();
let five_kilometer = Length::new_string("5 km").unwrap();

assert_eq!("2m", two_meter.get_original_string());
assert_eq!("5 km", five_kilometer.get_original_string());

Gets a normalized Length-struct.

Example
use length::{Length, Unit, MetricUnit::*};

let fivethousand_meter = Length::new_string("5000m").unwrap();
let five_kilometer = fivethousand_meter.normalize();

assert_eq!(5.0, five_kilometer.value);
assert_eq!(Unit::Metric(Kilometer), five_kilometer.unit);

Gets a normalized Length-struct.

Example
use length::{Length, Unit, MetricUnit::*};

let mut fivethousand_meter = Length::new_string("5000m").unwrap();
fivethousand_meter.normalize_by_ref();

assert_eq!(5.0, fivethousand_meter.value);
assert_eq!(Unit::Metric(Kilometer), fivethousand_meter.unit);

Converts this length into the given unit and returns a new Length-struct.

Example
use length::{Length, Unit, MetricUnit::*};

let five_kilometer = Length::new_string("5km").unwrap();
let fivethousand_meter1 = five_kilometer.to(Unit::Metric(Meter));
let fivethousand_meter2 = five_kilometer.to(Meter);

assert_eq!(5000.0, fivethousand_meter1.value);
assert_eq!(Unit::Metric(Meter), fivethousand_meter1.unit);
assert_eq!(5000.0, fivethousand_meter2.value);
assert_eq!(Unit::Metric(Meter), fivethousand_meter2.unit);

Converts this length into the given unit.

Example
use length::{Length, Unit, MetricUnit::*};

let mut five_kilometer = Length::new_string("5km").unwrap();
five_kilometer.to_by_ref(Unit::Metric(Meter));

assert_eq!(5000.0, five_kilometer.value);
assert_eq!(Unit::Metric(Meter), five_kilometer.unit);

five_kilometer.to_by_ref(Kilometer);

assert_eq!(5.0, five_kilometer.value);
assert_eq!(Unit::Metric(Kilometer), five_kilometer.unit);

Adds the length and returns a new Length-struct.

Example
use length::{Length, Unit, MetricUnit::*};

let five_kilometer = Length::new_string("5km").unwrap();
let twothousand_meter = Length::new_string("2000m").unwrap();
let seven_kilometer = five_kilometer.add(twothousand_meter);

assert_eq!(7.0, seven_kilometer.value);
assert_eq!(Unit::Metric(Kilometer), seven_kilometer.unit);

Adds the length.

Example
use length::{Length, Unit, MetricUnit::*};

let mut five_kilometer = Length::new_string("5km").unwrap();
let twothousand_meter = Length::new_string("2000m").unwrap();
five_kilometer.add_by_ref(twothousand_meter);

assert_eq!(7.0, five_kilometer.value);
assert_eq!(Unit::Metric(Kilometer), five_kilometer.unit);

Subtracts the length and returns a new Length-struct.

Example
use length::{Length, Unit, MetricUnit::*};

let five_kilometer = Length::new_string("5km").unwrap();
let twothousand_meter = Length::new_string("2000m").unwrap();
let three_kilometer = five_kilometer.subtract(twothousand_meter);

assert_eq!(3.0, three_kilometer.value);
assert_eq!(Unit::Metric(Kilometer), three_kilometer.unit);

Subtracts the length.

Example
use length::{Length, Unit, MetricUnit::*};

let mut five_kilometer = Length::new_string("5km").unwrap();
let twothousand_meter = Length::new_string("2000m").unwrap();
five_kilometer.subtract_by_ref(twothousand_meter);

assert_eq!(3.0, five_kilometer.value);
assert_eq!(Unit::Metric(Kilometer), five_kilometer.unit);

Multiplies the length and returns a new Length-struct.

Example
use length::{Length, Unit, MetricUnit::*};

let five_kilometer = Length::new_string("5km").unwrap();
let fifty_kilometer = five_kilometer.multiply_by(10);

assert_eq!(50.0, fifty_kilometer.value);
assert_eq!(Unit::Metric(Kilometer), fifty_kilometer.unit);

Multiplies the length by a factor.

Example
use length::{Length, Unit, MetricUnit::*};

let mut five_kilometer = Length::new_string("5km").unwrap();
five_kilometer.multiply_by_ref(10);

assert_eq!(50.0, five_kilometer.value);
assert_eq!(Unit::Metric(Kilometer), five_kilometer.unit);

Divides the length and returns a new Length-struct.

Example
use length::{Length, Unit, MetricUnit::*};

let five_kilometer = Length::new_string("5km").unwrap();
let one_kilometer = five_kilometer.divide_by(5);

assert_eq!(1.0, one_kilometer.value);
assert_eq!(Unit::Metric(Kilometer), one_kilometer.unit);

Divides the length by a factor.

Example
use length::{Length, Unit, MetricUnit::*};

let mut five_kilometer = Length::new_string("5km").unwrap();
five_kilometer.divide_by_ref(5);

assert_eq!(1.0, five_kilometer.value);
assert_eq!(Unit::Metric(Kilometer), five_kilometer.unit);

Trait Implementations§

Returns a copy of the value. Read more
Performs copy-assignment from source. Read more
Returns the “default value” for a type. Read more
Converts the given value to a String. Read more

Auto Trait Implementations§

Blanket Implementations§

Gets the TypeId of self. Read more
Immutably borrows from an owned value. Read more
Mutably borrows from an owned value. Read more

Returns the argument unchanged.

Calls U::from(self).

That is, this conversion is whatever the implementation of From<T> for U chooses to do.

The resulting type after obtaining ownership.
Creates owned data from borrowed data, usually by cloning. Read more
Uses borrowed data to replace owned data, usually by cloning. Read more
The type returned in the event of a conversion error.
Performs the conversion.
The type returned in the event of a conversion error.
Performs the conversion.