pub struct ItemOf<F: Inspect<AccountId>, A: Get<<F as Inspect<AccountId>>::AssetId>, AccountId>(_);
Expand description
Convert a fungibles
trait implementation into a fungible
trait implementation by identifying
a single item.
Trait Implementations§
source§impl<F: BalancedHold<AccountId>, A: Get<<F as Inspect<AccountId>>::AssetId>, AccountId> Balanced<AccountId> for ItemOf<F, A, AccountId>
impl<F: BalancedHold<AccountId>, A: Get<<F as Inspect<AccountId>>::AssetId>, AccountId> Balanced<AccountId> for ItemOf<F, A, AccountId>
source§fn slash(
reason: &Self::Reason,
who: &AccountId,
amount: Self::Balance
) -> (Credit<AccountId, Self>, Self::Balance)
fn slash( reason: &Self::Reason, who: &AccountId, amount: Self::Balance ) -> (Credit<AccountId, Self>, Self::Balance)
Reduce the balance of some funds on hold in an account. Read more
fn done_slash(_reason: &Self::Reason, _who: &AccountId, _amount: Self::Balance)
source§impl<F: Inspect<AccountId> + Unbalanced<AccountId> + Balanced<AccountId>, A: Get<<F as Inspect<AccountId>>::AssetId>, AccountId> Balanced<AccountId> for ItemOf<F, A, AccountId>
impl<F: Inspect<AccountId> + Unbalanced<AccountId> + Balanced<AccountId>, A: Get<<F as Inspect<AccountId>>::AssetId>, AccountId> Balanced<AccountId> for ItemOf<F, A, AccountId>
§type OnDropDebt = ConvertImbalanceDropHandler<AccountId, <ItemOf<F, A, AccountId> as Inspect<AccountId>>::Balance, <F as Inspect<AccountId>>::AssetId, A, <F as Balanced<AccountId>>::OnDropDebt>
type OnDropDebt = ConvertImbalanceDropHandler<AccountId, <ItemOf<F, A, AccountId> as Inspect<AccountId>>::Balance, <F as Inspect<AccountId>>::AssetId, A, <F as Balanced<AccountId>>::OnDropDebt>
The type for managing what happens when an instance of
Debt
is dropped without being used.§type OnDropCredit = ConvertImbalanceDropHandler<AccountId, <ItemOf<F, A, AccountId> as Inspect<AccountId>>::Balance, <F as Inspect<AccountId>>::AssetId, A, <F as Balanced<AccountId>>::OnDropCredit>
type OnDropCredit = ConvertImbalanceDropHandler<AccountId, <ItemOf<F, A, AccountId> as Inspect<AccountId>>::Balance, <F as Inspect<AccountId>>::AssetId, A, <F as Balanced<AccountId>>::OnDropCredit>
The type for managing what happens when an instance of
Credit
is dropped without being
used.source§fn deposit(
who: &AccountId,
value: Self::Balance,
precision: Precision
) -> Result<Debt<AccountId, Self>, DispatchError>
fn deposit( who: &AccountId, value: Self::Balance, precision: Precision ) -> Result<Debt<AccountId, Self>, DispatchError>
source§fn issue(amount: Self::Balance) -> Credit<AccountId, Self>
fn issue(amount: Self::Balance) -> Credit<AccountId, Self>
Increase the total issuance by
amount
and return the according imbalance. The imbalance
will typically be used to increase an account by the same amount with e.g.
resolve_into_existing
or resolve_creating
. Read moresource§fn pair(
amount: Self::Balance
) -> (Debt<AccountId, Self>, Credit<AccountId, Self>)
fn pair( amount: Self::Balance ) -> (Debt<AccountId, Self>, Credit<AccountId, Self>)
Produce a pair of imbalances that cancel each other out exactly. Read more
source§fn rescind(amount: Self::Balance) -> Debt<AccountId, Self>
fn rescind(amount: Self::Balance) -> Debt<AccountId, Self>
Reduce the total issuance by
amount
and return the according imbalance. The imbalance will
typically be used to reduce an account by the same amount with e.g. settle
. Read moresource§fn resolve(
who: &AccountId,
credit: Credit<AccountId, Self>
) -> Result<(), Credit<AccountId, Self>>
fn resolve( who: &AccountId, credit: Credit<AccountId, Self> ) -> Result<(), Credit<AccountId, Self>>
The balance of
who
is increased in order to counter credit
. If the whole of credit
cannot be countered, then nothing is changed and the original credit
is returned in an
Err
. Read moresource§fn settle(
who: &AccountId,
debt: Debt<AccountId, Self>,
preservation: Preservation
) -> Result<Credit<AccountId, Self>, Debt<AccountId, Self>>
fn settle( who: &AccountId, debt: Debt<AccountId, Self>, preservation: Preservation ) -> Result<Credit<AccountId, Self>, Debt<AccountId, Self>>
The balance of
who
is decreased in order to counter debt
. If the whole of debt
cannot be countered, then nothing is changed and the original debt
is returned in an
Err
.source§fn withdraw(
who: &AccountId,
value: Self::Balance,
precision: Precision,
preservation: Preservation,
force: Fortitude
) -> Result<Credit<AccountId, Self>, DispatchError>
fn withdraw( who: &AccountId, value: Self::Balance, precision: Precision, preservation: Preservation, force: Fortitude ) -> Result<Credit<AccountId, Self>, DispatchError>
fn done_rescind(_amount: Self::Balance)
fn done_issue(_amount: Self::Balance)
fn done_deposit(_who: &AccountId, _amount: Self::Balance)
fn done_withdraw(_who: &AccountId, _amount: Self::Balance)
source§impl<F: InspectFreeze<AccountId>, A: Get<<F as Inspect<AccountId>>::AssetId>, AccountId> Inspect<AccountId> for ItemOf<F, A, AccountId>
impl<F: InspectFreeze<AccountId>, A: Get<<F as Inspect<AccountId>>::AssetId>, AccountId> Inspect<AccountId> for ItemOf<F, A, AccountId>
source§fn balance_frozen(id: &Self::Id, who: &AccountId) -> Self::Balance
fn balance_frozen(id: &Self::Id, who: &AccountId) -> Self::Balance
Amount of funds held in reserve by
who
for the given id
.source§fn balance_freezable(who: &AccountId) -> Self::Balance
fn balance_freezable(who: &AccountId) -> Self::Balance
The amount of the balance which can become frozen. Defaults to
total_balance()
.source§fn can_freeze(id: &Self::Id, who: &AccountId) -> bool
fn can_freeze(id: &Self::Id, who: &AccountId) -> bool
Returns
true
if it’s possible to introduce a freeze for the given id
onto the
account of who
. This will be true as long as the implementor supports as many
concurrent freeze locks as there are possible values of id
.source§impl<F: Inspect<AccountId>, A: Get<<F as Inspect<AccountId>>::AssetId>, AccountId> Inspect<AccountId> for ItemOf<F, A, AccountId>
impl<F: Inspect<AccountId>, A: Get<<F as Inspect<AccountId>>::AssetId>, AccountId> Inspect<AccountId> for ItemOf<F, A, AccountId>
§type Balance = <F as Inspect<AccountId>>::Balance
type Balance = <F as Inspect<AccountId>>::Balance
Scalar type for representing balance of an account.
source§fn total_issuance() -> Self::Balance
fn total_issuance() -> Self::Balance
The total amount of issuance in the system.
source§fn active_issuance() -> Self::Balance
fn active_issuance() -> Self::Balance
The total amount of issuance in the system excluding those which are controlled by the
system.
source§fn minimum_balance() -> Self::Balance
fn minimum_balance() -> Self::Balance
The minimum balance any single account may have.
source§fn balance(who: &AccountId) -> Self::Balance
fn balance(who: &AccountId) -> Self::Balance
Get the balance of
who
which does not include funds which are exclusively allocated to
subsystems of the chain (“on hold” or “reserved”). Read moresource§fn total_balance(who: &AccountId) -> Self::Balance
fn total_balance(who: &AccountId) -> Self::Balance
Get the total amount of funds whose ultimate beneficial ownership can be determined as
who
. Read moresource§fn reducible_balance(
who: &AccountId,
preservation: Preservation,
force: Fortitude
) -> Self::Balance
fn reducible_balance( who: &AccountId, preservation: Preservation, force: Fortitude ) -> Self::Balance
Get the maximum amount that
who
can withdraw/transfer successfully based on whether the
account should be kept alive (preservation
) or whether we are willing to force the
reduction and potentially go below user-level restrictions on the minimum amount of the
account. Read moresource§fn can_deposit(
who: &AccountId,
amount: Self::Balance,
provenance: Provenance
) -> DepositConsequence
fn can_deposit( who: &AccountId, amount: Self::Balance, provenance: Provenance ) -> DepositConsequence
source§fn can_withdraw(
who: &AccountId,
amount: Self::Balance
) -> WithdrawConsequence<Self::Balance>
fn can_withdraw( who: &AccountId, amount: Self::Balance ) -> WithdrawConsequence<Self::Balance>
Returns
Success
if the balance of who
may be decreased by amount
, otherwise
the consequence.source§impl<F: InspectHold<AccountId>, A: Get<<F as Inspect<AccountId>>::AssetId>, AccountId> Inspect<AccountId> for ItemOf<F, A, AccountId>
impl<F: InspectHold<AccountId>, A: Get<<F as Inspect<AccountId>>::AssetId>, AccountId> Inspect<AccountId> for ItemOf<F, A, AccountId>
§type Reason = <F as Inspect<AccountId>>::Reason
type Reason = <F as Inspect<AccountId>>::Reason
An identifier for a hold. Used for disambiguating different holds so that
they can be individually replaced or removed and funds from one hold don’t accidentally
become unreserved or slashed for another.
source§fn reducible_total_balance_on_hold(
who: &AccountId,
force: Fortitude
) -> Self::Balance
fn reducible_total_balance_on_hold( who: &AccountId, force: Fortitude ) -> Self::Balance
Get the maximum amount that the
total_balance_on_hold
of who
can be reduced successfully
based on whether we are willing to force the reduction and potentially go below user-level
restrictions on the minimum amount of the account. Note: This cannot bring the account into
an inconsistent state with regards any required existential deposit. Read moresource§fn hold_available(reason: &Self::Reason, who: &AccountId) -> bool
fn hold_available(reason: &Self::Reason, who: &AccountId) -> bool
Returns
true
if it’s possible to place (additional) funds under a hold of a given
reason
. This may fail if the account has exhausted a limited number of concurrent
holds or if it cannot be made to exist (e.g. there is no provider reference). Read moresource§fn total_balance_on_hold(who: &AccountId) -> Self::Balance
fn total_balance_on_hold(who: &AccountId) -> Self::Balance
Amount of funds on hold (for all hold reasons) of
who
.source§fn balance_on_hold(reason: &Self::Reason, who: &AccountId) -> Self::Balance
fn balance_on_hold(reason: &Self::Reason, who: &AccountId) -> Self::Balance
Amount of funds on hold (for the given reason) of
who
.source§fn can_hold(
reason: &Self::Reason,
who: &AccountId,
amount: Self::Balance
) -> bool
fn can_hold( reason: &Self::Reason, who: &AccountId, amount: Self::Balance ) -> bool
Check to see if some
amount
of funds of who
may be placed on hold for the given
reason
. Reasons why this may not be true: Read moresource§fn ensure_can_hold(
reason: &Self::Reason,
who: &AccountId,
amount: Self::Balance
) -> DispatchResult
fn ensure_can_hold( reason: &Self::Reason, who: &AccountId, amount: Self::Balance ) -> DispatchResult
Check to see if some
amount
of funds of who
may be placed on hold with the given
reason
. Reasons why this may not be true: Read moresource§impl<F: MutateHold<AccountId>, A: Get<<F as Inspect<AccountId>>::AssetId>, AccountId> Mutate<AccountId> for ItemOf<F, A, AccountId>
impl<F: MutateHold<AccountId>, A: Get<<F as Inspect<AccountId>>::AssetId>, AccountId> Mutate<AccountId> for ItemOf<F, A, AccountId>
source§fn hold(
reason: &Self::Reason,
who: &AccountId,
amount: Self::Balance
) -> DispatchResult
fn hold( reason: &Self::Reason, who: &AccountId, amount: Self::Balance ) -> DispatchResult
Hold some funds in an account. If a hold for
reason
is already in place, then this
will increase it.source§fn release(
reason: &Self::Reason,
who: &AccountId,
amount: Self::Balance,
precision: Precision
) -> Result<Self::Balance, DispatchError>
fn release( reason: &Self::Reason, who: &AccountId, amount: Self::Balance, precision: Precision ) -> Result<Self::Balance, DispatchError>
Release up to
amount
held funds in an account. Read moresource§fn burn_held(
reason: &Self::Reason,
who: &AccountId,
amount: Self::Balance,
precision: Precision,
force: Fortitude
) -> Result<Self::Balance, DispatchError>
fn burn_held( reason: &Self::Reason, who: &AccountId, amount: Self::Balance, precision: Precision, force: Fortitude ) -> Result<Self::Balance, DispatchError>
source§fn transfer_on_hold(
reason: &Self::Reason,
source: &AccountId,
dest: &AccountId,
amount: Self::Balance,
precision: Precision,
mode: Restriction,
force: Fortitude
) -> Result<Self::Balance, DispatchError>
fn transfer_on_hold( reason: &Self::Reason, source: &AccountId, dest: &AccountId, amount: Self::Balance, precision: Precision, mode: Restriction, force: Fortitude ) -> Result<Self::Balance, DispatchError>
Transfer held funds into a destination account. Read more
source§fn transfer_and_hold(
reason: &Self::Reason,
source: &AccountId,
dest: &AccountId,
amount: Self::Balance,
precision: Precision,
preservation: Preservation,
force: Fortitude
) -> Result<Self::Balance, DispatchError>
fn transfer_and_hold( reason: &Self::Reason, source: &AccountId, dest: &AccountId, amount: Self::Balance, precision: Precision, preservation: Preservation, force: Fortitude ) -> Result<Self::Balance, DispatchError>
Transfer some
amount
of free balance from source
to become owned by dest
but on hold
for reason
. Read morefn done_hold(_reason: &Self::Reason, _who: &AccountId, _amount: Self::Balance)
fn done_release( _reason: &Self::Reason, _who: &AccountId, _amount: Self::Balance )
fn done_burn_held( _reason: &Self::Reason, _who: &AccountId, _amount: Self::Balance )
fn done_transfer_on_hold( _reason: &Self::Reason, _source: &AccountId, _dest: &AccountId, _amount: Self::Balance )
fn done_transfer_and_hold( _reason: &Self::Reason, _source: &AccountId, _dest: &AccountId, _transferred: Self::Balance )
source§impl<F: MutateFreeze<AccountId>, A: Get<<F as Inspect<AccountId>>::AssetId>, AccountId> Mutate<AccountId> for ItemOf<F, A, AccountId>
impl<F: MutateFreeze<AccountId>, A: Get<<F as Inspect<AccountId>>::AssetId>, AccountId> Mutate<AccountId> for ItemOf<F, A, AccountId>
source§fn set_freeze(
id: &Self::Id,
who: &AccountId,
amount: Self::Balance
) -> DispatchResult
fn set_freeze( id: &Self::Id, who: &AccountId, amount: Self::Balance ) -> DispatchResult
Prevent actions which would reduce the balance of the account of
who
below the given
amount
and identify this restriction though the given id
. Unlike extend_freeze
, any
outstanding freeze in place for who
under the id
are dropped. Read moresource§fn extend_freeze(
id: &Self::Id,
who: &AccountId,
amount: Self::Balance
) -> DispatchResult
fn extend_freeze( id: &Self::Id, who: &AccountId, amount: Self::Balance ) -> DispatchResult
Prevent the balance of the account of
who
from being reduced below the given amount
and
identify this restriction though the given id
. Unlike set_freeze
, this does not
counteract any pre-existing freezes in place for who
under the id
. Also unlike
set_freeze
, in the case that amount
is zero, this is no-op and never fails. Read moresource§fn thaw(id: &Self::Id, who: &AccountId) -> DispatchResult
fn thaw(id: &Self::Id, who: &AccountId) -> DispatchResult
Remove an existing lock.
source§impl<F: Mutate<AccountId>, A: Get<<F as Inspect<AccountId>>::AssetId>, AccountId> Mutate<AccountId> for ItemOf<F, A, AccountId>
impl<F: Mutate<AccountId>, A: Get<<F as Inspect<AccountId>>::AssetId>, AccountId> Mutate<AccountId> for ItemOf<F, A, AccountId>
source§fn mint_into(
who: &AccountId,
amount: Self::Balance
) -> Result<Self::Balance, DispatchError>
fn mint_into( who: &AccountId, amount: Self::Balance ) -> Result<Self::Balance, DispatchError>
Increase the balance of
who
by exactly amount
, minting new tokens. If that isn’t
possible then an Err
is returned and nothing is changed.source§fn burn_from(
who: &AccountId,
amount: Self::Balance,
precision: Precision,
force: Fortitude
) -> Result<Self::Balance, DispatchError>
fn burn_from( who: &AccountId, amount: Self::Balance, precision: Precision, force: Fortitude ) -> Result<Self::Balance, DispatchError>
Decrease the balance of
who
by at least amount
, possibly slightly more in the case of
minimum-balance requirements, burning the tokens. If that isn’t possible then an Err
is
returned and nothing is changed. If successful, the amount of tokens reduced is returned.source§fn shelve(
who: &AccountId,
amount: Self::Balance
) -> Result<Self::Balance, DispatchError>
fn shelve( who: &AccountId, amount: Self::Balance ) -> Result<Self::Balance, DispatchError>
source§fn restore(
who: &AccountId,
amount: Self::Balance
) -> Result<Self::Balance, DispatchError>
fn restore( who: &AccountId, amount: Self::Balance ) -> Result<Self::Balance, DispatchError>
source§fn transfer(
source: &AccountId,
dest: &AccountId,
amount: Self::Balance,
preservation: Preservation
) -> Result<Self::Balance, DispatchError>
fn transfer( source: &AccountId, dest: &AccountId, amount: Self::Balance, preservation: Preservation ) -> Result<Self::Balance, DispatchError>
Transfer funds from one account into another.
source§fn set_balance(who: &AccountId, amount: Self::Balance) -> Self::Balance
fn set_balance(who: &AccountId, amount: Self::Balance) -> Self::Balance
Simple infallible function to force an account to have a particular balance, good for use
in tests and benchmarks but not recommended for production code owing to the lack of
error reporting. Read more
fn done_mint_into(_who: &AccountId, _amount: Self::Balance)
fn done_burn_from(_who: &AccountId, _amount: Self::Balance)
fn done_shelve(_who: &AccountId, _amount: Self::Balance)
fn done_restore(_who: &AccountId, _amount: Self::Balance)
fn done_transfer(_source: &AccountId, _dest: &AccountId, _amount: Self::Balance)
source§impl<F: Unbalanced<AccountId>, A: Get<<F as Inspect<AccountId>>::AssetId>, AccountId> Unbalanced<AccountId> for ItemOf<F, A, AccountId>
impl<F: Unbalanced<AccountId>, A: Get<<F as Inspect<AccountId>>::AssetId>, AccountId> Unbalanced<AccountId> for ItemOf<F, A, AccountId>
source§fn handle_dust(dust: Dust<AccountId, Self>)where
Self: Sized,
fn handle_dust(dust: Dust<AccountId, Self>)where Self: Sized,
Do something with the dust which has been destroyed from the system.
Dust
can be converted
into a Credit
with the Balanced
trait impl.source§fn write_balance(
who: &AccountId,
amount: Self::Balance
) -> Result<Option<Self::Balance>, DispatchError>
fn write_balance( who: &AccountId, amount: Self::Balance ) -> Result<Option<Self::Balance>, DispatchError>
source§fn set_total_issuance(amount: Self::Balance)
fn set_total_issuance(amount: Self::Balance)
Set the total issuance to
amount
.source§fn decrease_balance(
who: &AccountId,
amount: Self::Balance,
precision: Precision,
preservation: Preservation,
force: Fortitude
) -> Result<Self::Balance, DispatchError>
fn decrease_balance( who: &AccountId, amount: Self::Balance, precision: Precision, preservation: Preservation, force: Fortitude ) -> Result<Self::Balance, DispatchError>
source§fn increase_balance(
who: &AccountId,
amount: Self::Balance,
precision: Precision
) -> Result<Self::Balance, DispatchError>
fn increase_balance( who: &AccountId, amount: Self::Balance, precision: Precision ) -> Result<Self::Balance, DispatchError>
source§fn handle_raw_dust(amount: Self::Balance)
fn handle_raw_dust(amount: Self::Balance)
Create some dust and handle it with
Self::handle_dust
. This is an unbalanced operation
and it must only be used when an account is modified in a raw fashion, outside of the entire
fungibles API. The amount
is capped at Self::minimum_balance() - 1
. Read moresource§fn deactivate(_: Self::Balance)
fn deactivate(_: Self::Balance)
Reduce the active issuance by some amount.
source§fn reactivate(_: Self::Balance)
fn reactivate(_: Self::Balance)
Increase the active issuance by some amount, up to the outstanding amount reduced.
source§impl<F: UnbalancedHold<AccountId>, A: Get<<F as Inspect<AccountId>>::AssetId>, AccountId> Unbalanced<AccountId> for ItemOf<F, A, AccountId>
impl<F: UnbalancedHold<AccountId>, A: Get<<F as Inspect<AccountId>>::AssetId>, AccountId> Unbalanced<AccountId> for ItemOf<F, A, AccountId>
source§fn set_balance_on_hold(
reason: &Self::Reason,
who: &AccountId,
amount: Self::Balance
) -> DispatchResult
fn set_balance_on_hold( reason: &Self::Reason, who: &AccountId, amount: Self::Balance ) -> DispatchResult
Forcefully set the balance on hold of
who
to amount
. This is independent of any other
balances on hold or the main (“free”) balance. Read moresource§fn decrease_balance_on_hold(
reason: &Self::Reason,
who: &AccountId,
amount: Self::Balance,
precision: Precision
) -> Result<Self::Balance, DispatchError>
fn decrease_balance_on_hold( reason: &Self::Reason, who: &AccountId, amount: Self::Balance, precision: Precision ) -> Result<Self::Balance, DispatchError>
source§fn increase_balance_on_hold(
reason: &Self::Reason,
who: &AccountId,
amount: Self::Balance,
precision: Precision
) -> Result<Self::Balance, DispatchError>
fn increase_balance_on_hold( reason: &Self::Reason, who: &AccountId, amount: Self::Balance, precision: Precision ) -> Result<Self::Balance, DispatchError>
Auto Trait Implementations§
impl<F, A, AccountId> RefUnwindSafe for ItemOf<F, A, AccountId>where A: RefUnwindSafe, AccountId: RefUnwindSafe, F: RefUnwindSafe,
impl<F, A, AccountId> Send for ItemOf<F, A, AccountId>where A: Send, AccountId: Send, F: Send,
impl<F, A, AccountId> Sync for ItemOf<F, A, AccountId>where A: Sync, AccountId: Sync, F: Sync,
impl<F, A, AccountId> Unpin for ItemOf<F, A, AccountId>where A: Unpin, AccountId: Unpin, F: Unpin,
impl<F, A, AccountId> UnwindSafe for ItemOf<F, A, AccountId>where A: UnwindSafe, AccountId: UnwindSafe, F: UnwindSafe,
Blanket Implementations§
source§impl<T> CheckedConversion for T
impl<T> CheckedConversion for T
source§impl<T> Instrument for T
impl<T> Instrument for T
source§fn instrument(self, span: Span) -> Instrumented<Self>
fn instrument(self, span: Span) -> Instrumented<Self>
source§fn in_current_span(self) -> Instrumented<Self>
fn in_current_span(self) -> Instrumented<Self>
source§impl<T, Outer> IsWrappedBy<Outer> for Twhere
Outer: AsRef<T> + AsMut<T> + From<T>,
T: From<Outer>,
impl<T, Outer> IsWrappedBy<Outer> for Twhere Outer: AsRef<T> + AsMut<T> + From<T>, T: From<Outer>,
§impl<T> Pointable for T
impl<T> Pointable for T
source§impl<T> SaturatedConversion for T
impl<T> SaturatedConversion for T
source§fn saturated_from<T>(t: T) -> Selfwhere
Self: UniqueSaturatedFrom<T>,
fn saturated_from<T>(t: T) -> Selfwhere Self: UniqueSaturatedFrom<T>,
source§fn saturated_into<T>(self) -> Twhere
Self: UniqueSaturatedInto<T>,
fn saturated_into<T>(self) -> Twhere Self: UniqueSaturatedInto<T>,
Consume self to return an equivalent value of
T
. Read moresource§impl<S, T> UncheckedInto<T> for Swhere
T: UncheckedFrom<S>,
impl<S, T> UncheckedInto<T> for Swhere T: UncheckedFrom<S>,
source§fn unchecked_into(self) -> T
fn unchecked_into(self) -> T
The counterpart to
unchecked_from
.source§impl<T, S> UniqueSaturatedInto<T> for Swhere
T: Bounded,
S: TryInto<T>,
impl<T, S> UniqueSaturatedInto<T> for Swhere T: Bounded, S: TryInto<T>,
source§fn unique_saturated_into(self) -> T
fn unique_saturated_into(self) -> T
Consume self to return an equivalent value of
T
.