Struct bitcoin::SignedAmount

pub struct SignedAmount(_);

SignedAmount

The SignedAmount type can be used to express Bitcoin amounts that support arithmetic and conversion to various denominations.

Warning!

This type implements several arithmetic operations from core::ops. To prevent errors due to overflow or underflow when using these operations, it is advised to instead use the checked arithmetic methods whose names start with checked_. The operations from core::ops that Amount implements will panic when overflow or underflow occurs.

Implementations

impl SignedAmount

pub const ZERO: SignedAmount = SignedAmount(0)

The zero amount.

pub const ONE_SAT: SignedAmount = SignedAmount(1)

Exactly one satoshi.

pub const ONE_BTC: SignedAmount = SignedAmount(100000000)

Exactly one bitcoin.

pub const MAX_MONEY: SignedAmount = SignedAmount(21000000 * 100000000)

The maximum value allowed as an amount. Useful for sanity checking.

pub const fn from_sat(satoshi: i64) -> SignedAmount

Create an SignedAmount with satoshi precision and the given number of satoshis.

pub fn to_sat(self) -> i64

Gets the number of satoshis in this SignedAmount.

pub const fn max_value() -> SignedAmount

The maximum value of an SignedAmount.

pub const fn min_value() -> SignedAmount

The minimum value of an SignedAmount.

pub fn from_btc(btc: f64) -> Result<SignedAmount, ParseAmountError>

Convert from a value expressing bitcoins to an SignedAmount.

pub fn from_str_in( s: &str, denom: Denomination ) -> Result<SignedAmount, ParseAmountError>

Parse a decimal string as a value in the given denomination.

Note: This only parses the value string. If you want to parse a value with denomination, use FromStr.

pub fn from_str_with_denomination( s: &str ) -> Result<SignedAmount, ParseAmountError>

Parses amounts with denomination suffix like they are produced with Self::to_string_with_denomination or with fmt::Display. If you want to parse only the amount without the denomination, use Self::from_str_in.

pub fn to_float_in(self, denom: Denomination) -> f64

Express this SignedAmount as a floating-point value in the given denomination.

Please be aware of the risk of using floating-point numbers.

pub fn to_btc(self) -> f64

Express this SignedAmount as a floating-point value in Bitcoin.

Equivalent to to_float_in(Denomination::Bitcoin).

Please be aware of the risk of using floating-point numbers.

pub fn from_float_in( value: f64, denom: Denomination ) -> Result<SignedAmount, ParseAmountError>

Convert this SignedAmount in floating-point notation with a given denomination. Can return error if the amount is too big, too precise or negative.

Please be aware of the risk of using floating-point numbers.

pub fn display_in(self, denomination: Denomination) -> Display

Create an object that implements fmt::Display using specified denomination.

pub fn display_dynamic(self) -> Display

Create an object that implements fmt::Display dynamically selecting denomination.

This will use BTC for values greater than or equal to 1 BTC and satoshis otherwise. To avoid confusion the denomination is always shown.

pub fn fmt_value_in( self, f: &mut dyn Write, denom: Denomination ) -> Result<(), Error>

Format the value of this SignedAmount in the given denomination.

Does not include the denomination.

pub fn to_string_in(self, denom: Denomination) -> String

Get a string number of this SignedAmount in the given denomination.

Does not include the denomination.

pub fn to_string_with_denomination(self, denom: Denomination) -> String

Get a formatted string of this SignedAmount in the given denomination, suffixed with the abbreviation for the denomination.

pub fn abs(self) -> SignedAmount

Get the absolute value of this SignedAmount.

pub fn signum(self) -> i64

Returns a number representing sign of this SignedAmount.

• 0 if the amount is zero
• 1 if the amount is positive
• -1 if the amount is negative

pub fn is_positive(self) -> bool

Returns true if this SignedAmount is positive and false if this SignedAmount is zero or negative.

pub fn is_negative(self) -> bool

Returns true if this SignedAmount is negative and false if this SignedAmount is zero or positive.

pub fn checked_abs(self) -> Option<SignedAmount>

Get the absolute value of this SignedAmount. Returns None if overflow occurred. (self == min_value())

pub fn checked_add(self, rhs: SignedAmount) -> Option<SignedAmount>

Checked addition. Returns None if overflow occurred.

pub fn checked_sub(self, rhs: SignedAmount) -> Option<SignedAmount>

Checked subtraction. Returns None if overflow occurred.

pub fn checked_mul(self, rhs: i64) -> Option<SignedAmount>

Checked multiplication. Returns None if overflow occurred.

pub fn checked_div(self, rhs: i64) -> Option<SignedAmount>

Checked integer division. Be aware that integer division loses the remainder if no exact division can be made. Returns None if overflow occurred.

pub fn checked_rem(self, rhs: i64) -> Option<SignedAmount>

Checked remainder. Returns None if overflow occurred.

pub fn positive_sub(self, rhs: SignedAmount) -> Option<SignedAmount>

Subtraction that doesn’t allow negative SignedAmounts. Returns None if either [self], rhs or the result is strictly negative.

pub fn to_unsigned(self) -> Result<Amount, ParseAmountError>

Convert to an unsigned amount.

Trait Implementations

impl Add<SignedAmount> for SignedAmount

type Output = SignedAmount

The resulting type after applying the + operator.

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

Performs the + operation.

impl AddAssign<SignedAmount> for SignedAmount

fn add_assign(&mut self, other: SignedAmount)

Performs the += operation.

impl Clone for SignedAmount

fn clone(&self) -> SignedAmount

Returns a copy of the value.

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

Performs copy-assignment from source.

impl Debug for SignedAmount

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

Formats the value using the given formatter.

impl Default for SignedAmount

fn default() -> SignedAmount

Returns the “default value” for a type.

impl Display for SignedAmount

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

Formats the value using the given formatter.

impl Div<i64> for SignedAmount

type Output = SignedAmount

The resulting type after applying the / operator.

fn div(self, rhs: i64) -> <SignedAmount as Div<i64>>::Output

Performs the / operation.

impl DivAssign<i64> for SignedAmount

fn div_assign(&mut self, rhs: i64)

Performs the /= operation.

impl FromStr for SignedAmount

type Err = ParseAmountError

The associated error which can be returned from parsing.

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

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

impl Hash for SignedAmount

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 Mul<i64> for SignedAmount

type Output = SignedAmount

The resulting type after applying the * operator.

fn mul(self, rhs: i64) -> <SignedAmount as Mul<i64>>::Output

Performs the * operation.

impl MulAssign<i64> for SignedAmount

fn mul_assign(&mut self, rhs: i64)

Performs the *= operation.

impl Ord for SignedAmount

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

This method returns an Ordering between self and other.

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

Compares and returns the maximum of two values.

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

Compares and returns the minimum of two values.

fn clamp(self, min: Self, max: Self) -> Selfwhere Self: Sized + PartialOrd<Self>,

Restrict a value to a certain interval.

impl PartialEq<SignedAmount> for SignedAmount

fn eq(&self, other: &SignedAmount) -> 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 PartialOrd<SignedAmount> for SignedAmount

fn partial_cmp(&self, other: &SignedAmount) -> 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 Rem<i64> for SignedAmount

type Output = SignedAmount

The resulting type after applying the % operator.

fn rem(self, modulus: i64) -> SignedAmount

Performs the % operation.

impl RemAssign<i64> for SignedAmount

fn rem_assign(&mut self, modulus: i64)

Performs the %= operation.

impl SerdeAmount for SignedAmount

fn ser_sat<S>( self, s: S ) -> Result<<S as Serializer>::Ok, <S as Serializer>::Error>where S: Serializer,

fn des_sat<'d, D>(d: D) -> Result<SignedAmount, <D as Deserializer<'d>>::Error>where D: Deserializer<'d>,

fn ser_btc<S>( self, s: S ) -> Result<<S as Serializer>::Ok, <S as Serializer>::Error>where S: Serializer,

fn des_btc<'d, D>(d: D) -> Result<SignedAmount, <D as Deserializer<'d>>::Error>where D: Deserializer<'d>,

impl SerdeAmountForOpt for SignedAmount

fn type_prefix() -> &'static str

fn ser_sat_opt<S>( self, s: S ) -> Result<<S as Serializer>::Ok, <S as Serializer>::Error>where S: Serializer,

fn ser_btc_opt<S>( self, s: S ) -> Result<<S as Serializer>::Ok, <S as Serializer>::Error>where S: Serializer,

impl Sub<SignedAmount> for SignedAmount

type Output = SignedAmount

The resulting type after applying the - operator.

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

Performs the - operation.

impl SubAssign<SignedAmount> for SignedAmount

fn sub_assign(&mut self, other: SignedAmount)

Performs the -= operation.

impl Sum<SignedAmount> for SignedAmount

fn sum<I>(iter: I) -> SignedAmountwhere I: Iterator<Item = SignedAmount>,

Method which takes an iterator and generates Self from the elements by “summing up” the items.

impl Copy for SignedAmount

impl Eq for SignedAmount

impl StructuralEq for SignedAmount

impl StructuralPartialEq for SignedAmount