Struct CommodityType

pub struct CommodityType {
    pub id: CommodityTypeID,
    pub name: Option<String>,
}

Represents a type of Commodity.

See CommodityTypeID for the primative which is genarally stored and used to refer to a given CommodityType.

Fields

id: CommodityTypeID

Stores the id of this commodity type in a fixed length ArrayString, with a maximum length of COMMODITY_TYPE_ID_LENGTH.

name: Option<String>

The human readable name of this commodity_type.

Implementations

impl CommodityType

pub fn new(id: CommodityTypeID, name: Option<String>) -> CommodityType

Create a new CommodityType.

Example

use std::str::FromStr;

let id = CommodityTypeID::from_str("AUD").unwrap();
let commodity_type = CommodityType::new(
    id,
    Some(String::from("Australian Dollar"))
);

assert_eq!(id, commodity_type.id);
assert_eq!(Some(String::from("Australian Dollar")), commodity_type.name);

pub fn from_str<SR: AsRef<str>, SI: Into<String>>( id: SR, name: SI, ) -> Result<CommodityType, CommodityError>

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

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

Example

use std::str::FromStr;

let commodity_type = CommodityType::from_str("AUD", "Australian dollar").unwrap();

assert_eq!(CommodityTypeID::from_str("AUD").unwrap(), commodity_type.id);
assert_eq!("Australian dollar", commodity_type.name.unwrap());

Trait Implementations

impl Clone for CommodityType

fn clone(&self) -> CommodityType

Returns a duplicate of the value.

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

Performs copy-assignment from source.

impl Debug for CommodityType

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

Formats the value using the given formatter.

impl<'de> Deserialize<'de> for CommodityType

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

where __D: Deserializer<'de>,

Deserialize this value from the given Serde deserializer.

impl Display for CommodityType

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

Formats the value using the given formatter.

impl From<&CommodityType> for CommodityTypeID

fn from(commodity_type: &CommodityType) -> CommodityTypeID

Converts to this type from the input type.

impl Hash for CommodityType

fn hash<H: Hasher>(&self, state: &mut H)

Feeds this value into the given Hasher.

fn hash_slice<H>(data: &[Self], state: &mut H)

where H: Hasher, Self: Sized,

Feeds a slice of this type into the given Hasher.

impl PartialEq for CommodityType

This implementation only checks that the ids match. It assumes that you will not have logical different commodity types with the same id but different names.

fn eq(&self, other: &Self) -> 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 Serialize for CommodityType

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

where __S: Serializer,

Serialize this value into the given Serde serializer.

impl Eq for CommodityType