Fields§
§unit: Unit
§value: f64
Implementations§
source§impl Length
impl Length
sourcepub fn new() -> Self
pub fn new() -> Self
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);
sourcepub fn new_value_unit<T: Into<f64>, U: Into<Unit>>(value: T, unit: U) -> Self
pub fn new_value_unit<T: Into<f64>, U: Into<Unit>>(value: T, unit: U) -> Self
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);
sourcepub fn new_string<S: Into<String>>(string: S) -> Option<Self>
pub fn new_string<S: Into<String>>(string: S) -> Option<Self>
Gets a new Option
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);
sourcepub fn get_original_string(&self) -> String
pub fn get_original_string(&self) -> String
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());
sourcepub fn normalize(&self) -> Self
pub fn normalize(&self) -> Self
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);
sourcepub fn normalize_by_ref(&mut self) -> &mut Self
pub fn normalize_by_ref(&mut self) -> &mut Self
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);
sourcepub fn to<T: Into<Unit>>(&self, destination_unit: T) -> Self
pub fn to<T: Into<Unit>>(&self, destination_unit: T) -> Self
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);
sourcepub fn to_by_ref<T: Into<Unit>>(&mut self, destination_unit: T) -> &mut Self
pub fn to_by_ref<T: Into<Unit>>(&mut self, destination_unit: T) -> &mut Self
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);
sourcepub fn add(&self, length: Length) -> Self
pub fn add(&self, length: Length) -> Self
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);
sourcepub fn add_by_ref(&mut self, length: Length) -> &mut Self
pub fn add_by_ref(&mut self, length: Length) -> &mut Self
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);
sourcepub fn subtract(&self, length: Length) -> Self
pub fn subtract(&self, length: Length) -> Self
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);
sourcepub fn subtract_by_ref(&mut self, length: Length) -> &mut Self
pub fn subtract_by_ref(&mut self, length: Length) -> &mut Self
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);
sourcepub fn multiply_by<T: Into<f64>>(&self, factor: T) -> Self
pub fn multiply_by<T: Into<f64>>(&self, factor: T) -> Self
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);
sourcepub fn multiply_by_ref<T: Into<f64>>(&mut self, factor: T) -> &mut Self
pub fn multiply_by_ref<T: Into<f64>>(&mut self, factor: T) -> &mut Self
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);
sourcepub fn divide_by<T: Into<f64>>(&self, factor: T) -> Self
pub fn divide_by<T: Into<f64>>(&self, factor: T) -> Self
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);
sourcepub fn divide_by_ref<T: Into<f64>>(&mut self, factor: T) -> &mut Self
pub fn divide_by_ref<T: Into<f64>>(&mut self, factor: T) -> &mut Self
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);