Expand description
Convert a fungibles
trait implementation into a fungible
trait implementation by identifying
a single item.
Trait Implementations
sourceimpl<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. Read moresourcefn 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>
sourcefn 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 moresourcefn 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
sourcefn 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 moresourcefn 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 moresourcefn 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
. Read moresourcefn 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)
sourceimpl<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>
sourceimpl<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.
sourcefn total_issuance() -> Self::Balance
fn total_issuance() -> Self::Balance
The total amount of issuance in the system.
sourcefn 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. Read more
sourcefn minimum_balance() -> Self::Balance
fn minimum_balance() -> Self::Balance
The minimum balance any single account may have.
sourcefn 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 moresourcefn total_balance(who: &AccountId) -> Self::Balance
fn total_balance(who: &AccountId) -> Self::Balance
Get the total amount of funds whose ultimate bneficial ownership can be determined as
who
. Read moresourcefn 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 moresourcefn can_deposit(
who: &AccountId,
amount: Self::Balance,
provenance: Provenance
) -> DepositConsequence
fn can_deposit(
who: &AccountId,
amount: Self::Balance,
provenance: Provenance
) -> DepositConsequence
sourcefn 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. Read moresourceimpl<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. Read more
sourcefn 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 moresourcefn 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 moresourcefn 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
.sourcefn 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
.sourcefn 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 moresourcefn 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 moresourceimpl<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>
sourcefn 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
.sourcefn 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()
.sourceimpl<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>
sourcefn 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. Read moresourcefn 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. Read moresourcefn 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.
sourcefn 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)
sourceimpl<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>
sourcefn 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. Read moresourcefn 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 moresourcefn 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>
sourcefn 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
sourcefn 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
)
sourceimpl<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>
sourcefn 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 moresourcefn 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 moresourcefn thaw(id: &Self::Id, who: &AccountId) -> DispatchResult
fn thaw(id: &Self::Id, who: &AccountId) -> DispatchResult
Remove an existing lock.
sourceimpl<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>
sourcefn 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. Read moresourcefn 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>
sourcefn set_total_issuance(amount: Self::Balance)
fn set_total_issuance(amount: Self::Balance)
Set the total issuance to
amount
.sourcefn 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>
sourcefn 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>
sourcefn 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 moresourcefn deactivate(_: Self::Balance)
fn deactivate(_: Self::Balance)
Reduce the active issuance by some amount.
sourcefn reactivate(_: Self::Balance)
fn reactivate(_: Self::Balance)
Increase the active issuance by some amount, up to the outstanding amount reduced.
sourceimpl<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>
sourcefn 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 moresourcefn 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>
sourcefn 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
sourceimpl<T> BorrowMut<T> for Twhere
T: ?Sized,
impl<T> BorrowMut<T> for Twhere
T: ?Sized,
const: unstable · sourcefn borrow_mut(&mut self) -> &mut T
fn borrow_mut(&mut self) -> &mut T
Mutably borrows from an owned value. Read more
sourceimpl<T> CheckedConversion for T
impl<T> CheckedConversion for T
sourcefn checked_from<T>(t: T) -> Option<Self>where
Self: TryFrom<T>,
fn checked_from<T>(t: T) -> Option<Self>where
Self: TryFrom<T>,
sourcefn checked_into<T>(self) -> Option<T>where
Self: TryInto<T>,
fn checked_into<T>(self) -> Option<T>where
Self: TryInto<T>,
impl<T> Downcast for Twhere
T: Any,
impl<T> Downcast for Twhere
T: Any,
fn into_any(self: Box<T, Global>) -> Box<dyn Any + 'static, Global>
fn into_any(self: Box<T, Global>) -> Box<dyn Any + 'static, Global>
Convert
Box<dyn Trait>
(where Trait: Downcast
) to Box<dyn Any>
. Box<dyn Any>
can
then be further downcast
into Box<ConcreteType>
where ConcreteType
implements Trait
. Read morefn into_any_rc(self: Rc<T>) -> Rc<dyn Any + 'static>
fn into_any_rc(self: Rc<T>) -> Rc<dyn Any + 'static>
Convert
Rc<Trait>
(where Trait: Downcast
) to Rc<Any>
. Rc<Any>
can then be
further downcast
into Rc<ConcreteType>
where ConcreteType
implements Trait
. Read morefn as_any(&self) -> &(dyn Any + 'static)
fn as_any(&self) -> &(dyn Any + 'static)
Convert
&Trait
(where Trait: Downcast
) to &Any
. This is needed since Rust cannot
generate &Any
’s vtable from &Trait
’s. Read morefn as_any_mut(&mut self) -> &mut (dyn Any + 'static)
fn as_any_mut(&mut self) -> &mut (dyn Any + 'static)
Convert
&mut Trait
(where Trait: Downcast
) to &Any
. This is needed since Rust cannot
generate &mut Any
’s vtable from &mut Trait
’s. Read moresourceimpl<T> Instrument for T
impl<T> Instrument for T
sourcefn instrument(self, span: Span) -> Instrumented<Self>
fn instrument(self, span: Span) -> Instrumented<Self>
sourcefn in_current_span(self) -> Instrumented<Self>
fn in_current_span(self) -> Instrumented<Self>
sourceimpl<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
sourceimpl<T> SaturatedConversion for T
impl<T> SaturatedConversion for T
sourcefn saturated_from<T>(t: T) -> Selfwhere
Self: UniqueSaturatedFrom<T>,
fn saturated_from<T>(t: T) -> Selfwhere
Self: UniqueSaturatedFrom<T>,
sourcefn 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 moresourceimpl<S, T> UncheckedInto<T> for Swhere
T: UncheckedFrom<S>,
impl<S, T> UncheckedInto<T> for Swhere
T: UncheckedFrom<S>,
sourcefn unchecked_into(self) -> T
fn unchecked_into(self) -> T
The counterpart to
unchecked_from
.sourceimpl<T, S> UniqueSaturatedInto<T> for Swhere
T: Bounded,
S: TryInto<T>,
impl<T, S> UniqueSaturatedInto<T> for Swhere
T: Bounded,
S: TryInto<T>,
sourcefn unique_saturated_into(self) -> T
fn unique_saturated_into(self) -> T
Consume self to return an equivalent value of
T
.