[][src]Trait frame_support::traits::Imbalance

#[must_use]pub trait Imbalance<Balance>: Sized + TryDrop {
    type Opposite: Imbalance<Balance>;
    pub fn zero() -> Self;
pub fn drop_zero(self) -> Result<(), Self>;
pub fn split(self, amount: Balance) -> (Self, Self);
pub fn merge(self, other: Self) -> Self;
pub fn subsume(&mut self, other: Self);
pub fn offset(self, other: Self::Opposite) -> Result<Self, Self::Opposite>;
pub fn peek(&self) -> Balance; pub fn ration(self, first: u32, second: u32) -> (Self, Self)
    where
        Balance: From<u32> + Saturating + Div<Output = Balance>
, { ... }
pub fn split_merge(
        self,
        amount: Balance,
        others: (Self, Self)
    ) -> (Self, Self) { ... }
pub fn ration_merge(
        self,
        first: u32,
        second: u32,
        others: (Self, Self)
    ) -> (Self, Self)
    where
        Balance: From<u32> + Saturating + Div<Output = Balance>
, { ... }
pub fn split_merge_into(self, amount: Balance, others: &mut (Self, Self)) { ... }
pub fn ration_merge_into(
        self,
        first: u32,
        second: u32,
        others: &mut (Self, Self)
    )
    where
        Balance: From<u32> + Saturating + Div<Output = Balance>
, { ... }
pub fn merge_into(self, other: &mut Self) { ... }
pub fn maybe_merge(self, other: Option<Self>) -> Self { ... }
pub fn maybe_subsume(&mut self, other: Option<Self>) { ... } }

A trait for a not-quite Linear Type that tracks an imbalance.

Functions that alter account balances return an object of this trait to express how much account balances have been altered in aggregate. If dropped, the currency system will take some default steps to deal with the imbalance (balances module simply reduces or increases its total issuance). Your module should generally handle it in some way, good practice is to do so in a configurable manner using an OnUnbalanced type for each situation in which your module needs to handle an imbalance.

Imbalances can either be Positive (funds were added somewhere without being subtracted elsewhere - e.g. a reward) or Negative (funds deducted somewhere without an equal and opposite addition - e.g. a slash or system fee payment).

Since they are unsigned, the actual type is always Positive or Negative. The trait makes no distinction except to define the Opposite type.

New instances of zero value can be created (zero) and destroyed (drop_zero).

Existing instances can be split and merged either consuming self with merge or mutating self with subsume. If the target is an Option, then maybe_merge and maybe_subsume might work better. Instances can also be offset with an Opposite that is less than or equal to in value.

You can always retrieve the raw balance value using peek.

Associated Types

type Opposite: Imbalance<Balance>

The oppositely imbalanced type. They come in pairs.

Loading content...

Required methods

pub fn zero() -> Self

The zero imbalance. Can be destroyed with drop_zero.

pub fn drop_zero(self) -> Result<(), Self>

Drop an instance cleanly. Only works if its self.value() is zero.

pub fn split(self, amount: Balance) -> (Self, Self)

Consume self and return two independent instances; the first is guaranteed to be at most amount and the second will be the remainder.

pub fn merge(self, other: Self) -> Self

Consume self and an other to return a new instance that combines both.

pub fn subsume(&mut self, other: Self)

Consume an other to mutate self into a new instance that combines both.

pub fn offset(self, other: Self::Opposite) -> Result<Self, Self::Opposite>

Consume self and along with an opposite counterpart to return a combined result.

Returns Ok along with a new instance of Self if this instance has a greater value than the other. Otherwise returns Err with an instance of the Opposite. In both cases the value represents the combination of self and other.

pub fn peek(&self) -> Balance

The raw value of self.

Loading content...

Provided methods

pub fn ration(self, first: u32, second: u32) -> (Self, Self) where
    Balance: From<u32> + Saturating + Div<Output = Balance>, 

Consume self and return two independent instances; the amounts returned will be in approximately the same ratio as first:second.

NOTE: This requires up to first + second room for a multiply, and first + second should fit into a u32. Overflow will safely saturate in both cases.

pub fn split_merge(self, amount: Balance, others: (Self, Self)) -> (Self, Self)

Consume self and add its two components, defined by the first component's balance, element-wise to two pre-existing Imbalances.

A convenient replacement for split and merge.

pub fn ration_merge(
    self,
    first: u32,
    second: u32,
    others: (Self, Self)
) -> (Self, Self) where
    Balance: From<u32> + Saturating + Div<Output = Balance>, 

Consume self and add its two components, defined by the ratio first:second, element-wise to two pre-existing Imbalances.

A convenient replacement for split and merge.

pub fn split_merge_into(self, amount: Balance, others: &mut (Self, Self))

Consume self and add its two components, defined by the first component's balance, element-wise into two pre-existing Imbalance refs.

A convenient replacement for split and subsume.

pub fn ration_merge_into(
    self,
    first: u32,
    second: u32,
    others: &mut (Self, Self)
) where
    Balance: From<u32> + Saturating + Div<Output = Balance>, 

Consume self and add its two components, defined by the ratio first:second, element-wise to two pre-existing Imbalances.

A convenient replacement for split and merge.

pub fn merge_into(self, other: &mut Self)

Consume self to mutate other so that it combines both. Just like subsume, only with reversed arguments.

pub fn maybe_merge(self, other: Option<Self>) -> Self

Consume self and maybe an other to return a new instance that combines both.

pub fn maybe_subsume(&mut self, other: Option<Self>)

Maybe consume an other to mutate self into a new instance that combines both.

Loading content...

Implementors

Loading content...