Struct Length 

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

Fields

unit: Unit

value: f64

Implementations

impl Length

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);

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);

pub fn new_string<S: Into<String>>(string: S) -> Option<Self>

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);

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());

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);

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);

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);

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);

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);

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);

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);

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);

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);

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);

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);

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);

Trait Implementations

impl Clone for Length

fn clone(&self) -> Length

Returns a duplicate of the value.

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

Performs copy-assignment from source.

impl Default for Length

fn default() -> Length

Returns the “default value” for a type.

impl ToString for Length

fn to_string(&self) -> String

Converts the given value to a String.