Struct Commodity

pub struct Commodity {
    pub value: Decimal,
    pub type_id: CommodityTypeID,
}

A commodity, which holds a value with an associated CommodityType

Fields

value: Decimal

The value of this commodity

type_id: CommodityTypeID

The id of the type of this commodity

Implementations

impl Commodity

pub fn new<T: Into<CommodityTypeID>>(value: Decimal, type_id: T) -> Commodity

Create a new Commodity.

Example

use commodity::{Commodity, CommodityTypeID};
use std::str::FromStr;
use rust_decimal::Decimal;

let type_id = CommodityTypeID::from_str("USD").unwrap();
let commodity = Commodity::new(Decimal::new(202, 2), type_id);

assert_eq!(Decimal::from_str("2.02").unwrap(), commodity.value);
assert_eq!(type_id, commodity.type_id)

Using using the Into trait to accept CommodityType as the type_id:

use commodity::{Commodity, CommodityType};
use std::str::FromStr;
use rust_decimal::Decimal;

let commodity_type = CommodityType::from_currency_alpha3("USD").unwrap();
let commodity = Commodity::new(Decimal::new(202, 2), &commodity_type);

pub fn zero(type_id: CommodityTypeID) -> Commodity

Create a commodity with a value of zero

pub fn add(&self, other: &Commodity) -> Result<Commodity, CommodityError>

Add the value of commodity other to self such that result = self + other.

Example

use rust_decimal::Decimal;
use std::str::FromStr;

let type_id = CommodityTypeID::from_str("USD").unwrap();
let commodity1 = Commodity::new(Decimal::new(400, 2), type_id);
let commodity2 = Commodity::new(Decimal::new(250, 2), type_id);

// perform the add
let result = commodity1.add(&commodity2).unwrap();

assert_eq!(Decimal::new(650, 2), result.value);
assert_eq!(type_id, result.type_id);

pub fn sub(&self, other: &Commodity) -> Result<Commodity, CommodityError>

Subtract the value of commodity other from self such that result = self - other.

Example

use rust_decimal::Decimal;
use std::str::FromStr;

let usd = CommodityTypeID::from_str("USD").unwrap();
let commodity1 = Commodity::new(Decimal::new(400, 2), usd);
let commodity2 = Commodity::new(Decimal::new(250, 2), usd);

// perform the subtraction
let result = commodity1.sub(&commodity2).unwrap();

assert_eq!(Decimal::new(150, 2), result.value);
assert_eq!(usd, result.type_id);

pub fn neg(&self) -> Commodity

Negate the value of this commodity such that result = -self

Example

use rust_decimal::Decimal;

let type_id = CommodityTypeID::from_str("USD").unwrap();
let commodity = Commodity::new(Decimal::new(202, 2), type_id);

// perform the negation
let result = commodity.neg();

assert_eq!(Decimal::from_str("-2.02").unwrap(), result.value);
assert_eq!(type_id, result.type_id)

pub fn div_i64(&self, i: i64) -> Commodity

Divide this commodity by the specified integer value

Example

use rust_decimal::{Decimal};
use std::str::FromStr;

let commodity = Commodity::from_str("4.03 AUD").unwrap();
let result = commodity.div_i64(4);
assert_eq!(Decimal::new(10075, 4), result.value);

pub fn divide_share(&self, i: i64, dp: u32) -> Vec<Commodity>

Divide this commodity by the specified integer value

Example

use rust_decimal::{Decimal};
use std::str::FromStr;

let commodity = Commodity::from_str("4.03 AUD").unwrap();
let results = commodity.divide_share(4, 2);

assert_eq!(Decimal::new(101, 2), results.get(0).unwrap().value);
assert_eq!(Decimal::new(101, 2), results.get(1).unwrap().value);
assert_eq!(Decimal::new(101, 2), results.get(2).unwrap().value);
assert_eq!(Decimal::new(100, 2), results.get(3).unwrap().value);

pub fn convert(&self, type_id: CommodityTypeID, rate: Decimal) -> Commodity

Convert this commodity to a different commodity_type using a conversion rate.

Example

use rust_decimal::Decimal;
use std::str::FromStr;

let aud = Commodity::from_str("100.00 AUD").unwrap();
let usd = aud.convert(CommodityTypeID::from_str("USD").unwrap(), Decimal::from_str("0.01").unwrap());

assert_eq!(Decimal::from_str("1.00").unwrap(), usd.value);
assert_eq!("USD", usd.type_id);

pub fn compatible_with(&self, other: &Commodity) -> bool

Returns true if the currencies of both this commodity, and the other commodity are compatible for numeric operations.

Example

use std::str::FromStr;

let aud1 = Commodity::from_str("1.0 AUD").unwrap();
let aud2 = Commodity::from_str("2.0 AUD").unwrap();
let nzd = Commodity::from_str("1.0 NZD").unwrap();

assert!(aud1.compatible_with(&aud2));
assert!(!aud1.compatible_with(&nzd));

pub fn lt(&self, other: &Commodity) -> Result<bool, CommodityError>

Compare whether this commodity has a value less than another commodity.

Will return an error if the commodities have incompatible currencies.

Example

use std::str::FromStr;

let aud1 = Commodity::from_str("1.0 AUD").unwrap();
let aud2 = Commodity::from_str("2.0 AUD").unwrap();

assert_eq!(true, aud1.lt(&aud2).unwrap());
assert_eq!(false, aud2.lt(&aud1).unwrap());

pub fn gt(&self, other: &Commodity) -> Result<bool, CommodityError>

Compare whether this commodity has a value greater than another commodity.

Will return an error if the commodities have incompatible currencies.

Example

use std::str::FromStr;

let aud1 = Commodity::from_str("1.0 AUD").unwrap();
let aud2 = Commodity::from_str("2.0 AUD").unwrap();

assert_eq!(false, aud1.gt(&aud2).unwrap());
assert_eq!(true, aud2.gt(&aud1).unwrap());

pub fn abs(&self) -> Commodity

Return the absolute value of this commodity (if the value is negative, then make it positive).

Example

use std::str::FromStr;

let aud1 = Commodity::from_str("-1.0 AUD").unwrap();
assert_eq!(Commodity::from_str("1.0 AUD").unwrap(), aud1.abs());

let aud2 = Commodity::from_str("2.0 AUD").unwrap();
assert_eq!(Commodity::from_str("2.0 AUD").unwrap(), aud2.abs());

pub fn default_epsilon() -> Decimal

The default epsilon to use for comparisons between different Commoditys.

pub fn eq_approx(&self, other: Commodity, epsilon: Decimal) -> bool

Trait Implementations

impl Clone for Commodity

fn clone(&self) -> Commodity

Returns a duplicate of the value.

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

Performs copy-assignment from source.

impl Debug for Commodity

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

Formats the value using the given formatter.

impl<'de> Deserialize<'de> for Commodity

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

where __D: Deserializer<'de>,

Deserialize this value from the given Serde deserializer.

impl Display for Commodity

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

Formats the value using the given formatter.

impl FromStr for Commodity

fn from_str(commodity_string: &str) -> Result<Commodity, CommodityError>

Construct a Commodity from a string

Example

use std::str::FromStr;
use rust_decimal::Decimal;

let commodity = Commodity::from_str("1.234 USD").unwrap();

assert_eq!(Decimal::from_str("1.234").unwrap(), commodity.value);
assert_eq!(CommodityTypeID::from_str("USD").unwrap(), commodity.type_id);

type Err = CommodityError

The associated error which can be returned from parsing.

impl Ord for Commodity

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

This method returns an Ordering between self and other.

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

where Self: Sized,

Compares and returns the maximum of two values.

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

where Self: Sized,

Compares and returns the minimum of two values.

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

where Self: Sized,

Restrict a value to a certain interval.

impl PartialEq for Commodity

fn eq(&self, other: &Commodity) -> bool

Tests for self and other values to be equal, and is used by ==.

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

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

impl PartialOrd for Commodity

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

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

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

Tests less than (for self and other) and is used by the < operator.

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

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

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

Tests greater than (for self and other) and is used by the > operator.

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

Tests greater than or equal to (for self and other) and is used by the >= operator.

impl Serialize for Commodity

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

where __S: Serializer,

Serialize this value into the given Serde serializer.

impl Copy for Commodity

impl Eq for Commodity

impl StructuralPartialEq for Commodity