Struct monet::Money

pub struct Money {
    pub amount: CurrencyAmount,
    pub currency_code: CurrencyCode,
}

A struct containing an amount of money having a certain currency_code. Note that amount contains fractions of a unit. See AMOUNT_UNIT.

Examples

use monet::{Money, CurrencyAmount, Rates, Operation};
use std::convert::TryInto;

// Custom rates.
let map = vec![("USD", 1_000_000)].into_iter()
    .map(|(code, worth)| (code.try_into().unwrap(), worth.into()))
    .collect();
let rates = Rates::with_rates(map);

let money_owned = Money::with_str_code(CurrencyAmount::with_unit(2), "USD").unwrap();
let money_paid = Money::with_str_code(CurrencyAmount::with_unit(1), "USD").unwrap();

let remaining = (money_owned - money_paid).execute(&rates);

assert_eq!(remaining, Money::with_str_code(CurrencyAmount::with_unit(1), "USD"));

Fields

amount: CurrencyAmount

currency_code: CurrencyCode

Methods

impl Money

pub fn new(amount: CurrencyAmount, currency_code: CurrencyCode) -> Self

pub fn into_code(self, code: CurrencyCode, rates: &Rates) -> Option<Money>

pub fn with_str_code(
    amount: CurrencyAmount,
    currency_code: &str
) -> Option<Money>

Creates Money with given amount and code. Returns None if the given code is not three characters long.

Trait Implementations

impl Operation for Money

fn execute(self, _rates: &Rates) -> Option<Money>

Execute this operation agains some defined rates.

impl Clone for Money

fn clone(&self) -> Money

Returns a copy of the value.

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

Performs copy-assignment from source.

impl Copy for Money

impl Default for Money

fn default() -> Money

Returns the "default value" for a type.

impl Eq for Money

impl PartialEq<Money> for Money

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

This method tests for self and other values to be equal, and is used by ==.

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

This method tests for !=.

impl Display for Money

Money can be displayed in the following format: 12.10 CHF.

Default precision is dependent on the currency code (see ISO 4217 exponent). A custom precision in range 0..=6 can be provided like this:

use monet::Money;

let money = Money::with_str_code(12_100_000.into(), "CHF").unwrap();

assert_eq!(
    &format!("{}", money),
    "12.10 CHF"
);

assert_eq!(
    &format!("{:.2}", money),
    "12.10 CHF"
);

assert_eq!(
    &format!("{:.6}", money),
    "12.100000 CHF"
);

// Note: the formatted version has lost a decimal due to the
// lower precision
assert_eq!(
    &format!("{:.0}", money),
    "12 CHF"
);

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

Formats the value using the given formatter.

impl Debug for Money

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

Formats the value using the given formatter.

impl Div<Exponent> for Money

type Output = Div<Self>

The resulting type after applying the / operator.

fn div(self, exp: Exponent) -> Self::Output

Performs the / operation.

impl<O: Operation> Sub<O> for Money

type Output = Sub<Self, O>

The resulting type after applying the - operator.

fn sub(self, other: O) -> Self::Output

Performs the - operation.

impl<O: Operation> Add<O> for Money

type Output = Add<Self, O>

The resulting type after applying the + operator.

fn add(self, other: O) -> Self::Output

Performs the + operation.

impl Mul<Exponent> for Money

type Output = Mul<Self>

The resulting type after applying the * operator.

fn mul(self, exp: Exponent) -> Self::Output

Performs the * operation.

impl StructuralPartialEq for Money

impl StructuralEq for Money