Struct currencies::amount::Amount

pub struct Amount<C = USD, Safety = Unchecked>(/* private fields */)
where
    C: Currency,
    Safety: Safety;

Generically represents an amount of a specified Currency.

Setting Self::Safety to Unchecked will allow for full use of all supported math operators, but allows for things like overflowing, division by zero, that can lead to panics during runtime.

Setting Self::Safety to Checked replaces basic arithmetic operators with their checked counterparts that can never panic but typically return an Option or Result that must be used. This should make usages of this Amount 100% safe to use in situations where panicking is dangerous.

Implementations

impl<C, Safety> Amount<C, Safety>

where C: Currency, Safety: Safety,

pub fn raw_backing(&self) -> <C as Currency>::Backing

Allows direct access to the raw Backing value used to internally represent this Amount.

pub fn raw_backing_mut(&mut self) -> &mut <C as Currency>::Backing

Allows direct mutable access to the raw Backing value used to internally represent this Amount.

This method should be used with care as no checks are performed when directly manipulating the internal Backing.

impl<C, Safety> Amount<C, Safety>

where C: Currency, Safety: Safety,

pub const fn from_raw(amount: <C as Currency>::Backing) -> Amount<C, Safety>

Constructs an Amount from a compatible raw Backing value.

Trait Implementations

impl<C> Add for Amount<C>

where C: Currency,

type Output = Amount<C>

The resulting type after applying the + operator.

fn add(self, rhs: Amount<C>) -> <Amount<C> as Add>::Output

Performs the + operation.

impl<C> Add for Amount<C, Checked>

where C: Currency,

type Output = Option<Amount<C, Checked>>

The resulting type after applying the + operator.

fn add(self, rhs: Amount<C, Checked>) -> <Amount<C, Checked> as Add>::Output

Performs the + operation.

impl<C> AddAssign for Amount<C>

where C: Currency,

fn add_assign(&mut self, rhs: Amount<C>)

Performs the += operation.

impl<C, Safety> Clone for Amount<C, Safety>

where C: Clone + Currency, Safety: Clone + Safety, <C as Currency>::Backing: Clone,

fn clone(&self) -> Amount<C, Safety>

Returns a copy of the value.

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

Performs copy-assignment from source.

impl<C, Safety> Debug for Amount<C, Safety>

where C: Currency, Safety: Safety,

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

Formats the value using the given formatter.

impl<'de, C, Safety> Deserialize<'de> for Amount<C, Safety>

where C: Currency, Safety: Safety, Amount<C, Safety>: FromStr<Err = Error>,

fn deserialize<D>( deserializer: D, ) -> Result<Amount<C, Safety>, <D as Deserializer<'de>>::Error>

where D: Deserializer<'de>,

Deserialize this value from the given Serde deserializer.

impl<C, Safety> Display for Amount<C, Safety>

where C: Currency, Safety: Safety,

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

Formats the value using the given formatter.

impl<C> Div for Amount<C>

where C: Currency,

type Output = <C as Currency>::Backing

The resulting type after applying the / operator.

fn div(self, rhs: Amount<C>) -> <Amount<C> as Div>::Output

Performs the / operation.

impl<C> Div for Amount<C, Checked>

where C: Currency,

type Output = Option<<C as Currency>::Backing>

The resulting type after applying the / operator.

fn div(self, rhs: Amount<C, Checked>) -> <Amount<C, Checked> as Div>::Output

Performs the / operation.

impl<C> From<Amount<C>> for Amount<C, Checked>

where C: Currency,

fn from(amount: Amount<C>) -> Amount<C, Checked>

Converts to this type from the input type.

impl<C> From<Amount<C, Checked>> for Amount<C>

where C: Currency,

fn from(amount: Amount<C, Checked>) -> Amount<C>

Converts to this type from the input type.

impl<C, Safety> FromStr for Amount<C, Safety>

where C: Currency, Safety: Safety,

type Err = Error

The associated error which can be returned from parsing.

fn from_str( s: &str, ) -> Result<Amount<C, Safety>, <Amount<C, Safety> as FromStr>::Err>

Parses a string s to return a value of this type.

impl<C, Safety> Hash for Amount<C, Safety>

where C: Hash + Currency, Safety: Hash + Safety, <C as Currency>::Backing: Hash,

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

where __H: Hasher,

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<C> Mul<i32> for Amount<C>

where C: Currency, <C as Currency>::Backing: FromPrimitive,

type Output = Amount<C>

The resulting type after applying the * operator.

fn mul(self, rhs: i32) -> <Amount<C> as Mul<i32>>::Output

Performs the * operation.

impl<C> Mul<u128> for Amount<C>

where C: Currency, <C as Currency>::Backing: FromPrimitive,

type Output = Amount<C>

The resulting type after applying the * operator.

fn mul(self, rhs: u128) -> <Amount<C> as Mul<u128>>::Output

Performs the * operation.

impl<C> Mul<u16> for Amount<C>

where C: Currency, <C as Currency>::Backing: FromPrimitive,

type Output = Amount<C>

The resulting type after applying the * operator.

fn mul(self, rhs: u16) -> <Amount<C> as Mul<u16>>::Output

Performs the * operation.

impl<C> Mul<u32> for Amount<C>

where C: Currency, <C as Currency>::Backing: FromPrimitive,

type Output = Amount<C>

The resulting type after applying the * operator.

fn mul(self, rhs: u32) -> <Amount<C> as Mul<u32>>::Output

Performs the * operation.

impl<C> Mul<u64> for Amount<C>

where C: Currency, <C as Currency>::Backing: FromPrimitive,

type Output = Amount<C>

The resulting type after applying the * operator.

fn mul(self, rhs: u64) -> <Amount<C> as Mul<u64>>::Output

Performs the * operation.

impl<C> Mul<u8> for Amount<C>

where C: Currency, <C as Currency>::Backing: FromPrimitive,

type Output = Amount<C>

The resulting type after applying the * operator.

fn mul(self, rhs: u8) -> <Amount<C> as Mul<u8>>::Output

Performs the * operation.

impl<C> Mul<usize> for Amount<C>

where C: Currency, <C as Currency>::Backing: FromPrimitive,

type Output = Amount<C>

The resulting type after applying the * operator.

fn mul(self, rhs: usize) -> <Amount<C> as Mul<usize>>::Output

Performs the * operation.

impl<C> Mul for Amount<C>

where C: Currency,

type Output = Amount<C>

The resulting type after applying the * operator.

fn mul(self, rhs: Amount<C>) -> <Amount<C> as Mul>::Output

Performs the * operation.

impl<C> Mul for Amount<C, Checked>

where C: Currency,

type Output = Option<Amount<C, Checked>>

The resulting type after applying the * operator.

fn mul(self, rhs: Amount<C, Checked>) -> <Amount<C, Checked> as Mul>::Output

Performs the * operation.

impl<C> MulAssign for Amount<C>

where C: Currency,

fn mul_assign(&mut self, rhs: Amount<C>)

Performs the *= operation.

impl<C> One for Amount<C>

where C: Currency,

fn one() -> Amount<C>

Returns the multiplicative identity element of Self, 1.

fn set_one(&mut self)

Sets self to the multiplicative identity element of Self, 1.

fn is_one(&self) -> bool

where Self: PartialEq,

Returns true if self is equal to the multiplicative identity.

impl<C, Safety> Ord for Amount<C, Safety>

where C: Ord + Currency, Safety: Ord + Safety, <C as Currency>::Backing: Ord,

fn cmp(&self, other: &Amount<C, Safety>) -> 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 + PartialOrd,

Restrict a value to a certain interval.

impl<C, Safety> PartialEq for Amount<C, Safety>

where C: PartialEq + Currency, Safety: PartialEq + Safety, <C as Currency>::Backing: PartialEq,

fn eq(&self, other: &Amount<C, Safety>) -> bool

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

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

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

impl<C, Safety> PartialOrd for Amount<C, Safety>

where C: PartialOrd + Currency, Safety: PartialOrd + Safety, <C as Currency>::Backing: PartialOrd,

fn partial_cmp(&self, other: &Amount<C, Safety>) -> Option<Ordering>

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

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

This method tests less than (for self and other) and is used by the < operator.

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

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

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

This method tests greater than (for self and other) and is used by the > operator.

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

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

impl<C, Safety> Rem for Amount<C, Safety>

where C: Currency, Safety: Safety,

type Output = Amount<C, Safety>

The resulting type after applying the % operator.

fn rem(self, rhs: Amount<C, Safety>) -> <Amount<C, Safety> as Rem>::Output

Performs the % operation.

impl<C, Safety> Serialize for Amount<C, Safety>

where C: Currency, Safety: Safety,

fn serialize<S>( &self, serializer: S, ) -> Result<<S as Serializer>::Ok, <S as Serializer>::Error>

where S: Serializer,

Serialize this value into the given Serde serializer.

impl<C> Sub for Amount<C>

where C: Currency,

type Output = Amount<C>

The resulting type after applying the - operator.

fn sub(self, rhs: Amount<C>) -> <Amount<C> as Sub>::Output

Performs the - operation.

impl<C> Sub for Amount<C, Checked>

where C: Currency,

type Output = Option<Amount<C, Checked>>

The resulting type after applying the - operator.

fn sub(self, rhs: Amount<C, Checked>) -> <Amount<C, Checked> as Sub>::Output

Performs the - operation.

impl<C> SubAssign for Amount<C>

where C: Currency,

fn sub_assign(&mut self, rhs: Amount<C>)

Performs the -= operation.

impl<C> Zero for Amount<C>

where C: Currency,

fn zero() -> Amount<C>

Returns the additive identity element of Self, 0.

fn is_zero(&self) -> bool

Returns true if self is equal to the additive identity.

fn set_zero(&mut self)

Sets self to the additive identity element of Self, 0.

impl<C, Safety> Copy for Amount<C, Safety>

where C: Copy + Currency, Safety: Copy + Safety, <C as Currency>::Backing: Copy,

impl<C, Safety> Eq for Amount<C, Safety>

where C: Eq + Currency, Safety: Eq + Safety, <C as Currency>::Backing: Eq,

impl<C, Safety> StructuralPartialEq for Amount<C, Safety>

where C: Currency, Safety: Safety,