Struct commodity::Currency

pub struct Currency {
    pub code: CurrencyCode,
    pub name: Option<String>,
}

Represents a the type of currency held in a Commodity. See CurrencyCode for the primative which is genarally stored and used to refer to a given Currency.

Fields

code: CurrencyCode

Stores the code/id of this currency in a fixed length ArrayString, with a maximum length of CURRENCY_CODE_LENGTH.

name: Option<String>

The human readable name of this currency.

Methods

impl Currency

pub fn new(code: CurrencyCode, name: Option<String>) -> Currency

Create a new Currency

Example

use std::str::FromStr;

let code = CurrencyCode::from_str("AUD").unwrap();
let currency = Currency::new(
    code,
    Some(String::from("Australian Dollar"))
);

assert_eq!(code, currency.code);
assert_eq!(Some(String::from("Australian Dollar")), currency.name);

pub fn from_str(code: &str, name: &str) -> Result<Currency, CommodityError>

Create a Currency from strings, usually for debugging, or unit testing purposes.

code is an array backed string that has a fixed maximum size of CURRENCY_CODE_LENGTH. The supplied string must not exeed this, or a CommodityError::TooLongCurrencyCode will be returned.

Example

use std::str::FromStr;

let currency = Currency::from_str("AUD", "Australian dollar").unwrap();

assert_eq!(CurrencyCode::from_str("AUD").unwrap(), currency.code);
assert_eq!("Australian dollar", currency.name.unwrap());

pub fn from_alpha3(alpha3: &str) -> Result<Currency, CommodityError>

Construct a Currency by looking it up in the iso4217 currency database.

Example

let currency = Currency::from_alpha3("AUD").unwrap();
assert_eq!("AUD", currency.code);
assert_eq!(Some(String::from("Australian dollar")), currency.name);

Trait Implementations

impl Clone for Currency

fn clone(&self) -> Currency

Returns a copy of the value.

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

Performs copy-assignment from source.

impl Debug for Currency

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

Formats the value using the given formatter.

impl<'de> Deserialize<'de> for Currency

fn deserialize<__D>(__deserializer: __D) -> Result<Self, __D::Error> where
    __D: Deserializer<'de>, 

Deserialize this value from the given Serde deserializer.

impl<'_> From<&'_ Currency> for CurrencyCode

fn from(currency: &Currency) -> CurrencyCode

Performs the conversion.

impl Serialize for Currency

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

Serialize this value into the given Serde serializer.