Struct pallet_restricted_tokens::pallet::Pallet
source · pub struct Pallet<T>(/* private fields */);
Expand description
The Pallet
struct, the main type that implements traits and standalone
functions within the pallet.
Implementations§
source§impl<T: Config> Pallet<T>
impl<T: Config> Pallet<T>
pub fn transfer( origin: OriginFor<T>, dest: <T::Lookup as StaticLookup>::Source, currency_id: T::CurrencyId, amount: T::Balance ) -> DispatchResultWithPostInfo
pub fn transfer_all( origin: OriginFor<T>, dest: <T::Lookup as StaticLookup>::Source, currency_id: T::CurrencyId, keep_alive: bool ) -> DispatchResultWithPostInfo
pub fn transfer_keep_alive( origin: OriginFor<T>, dest: <T::Lookup as StaticLookup>::Source, currency_id: T::CurrencyId, amount: T::Balance ) -> DispatchResultWithPostInfo
pub fn force_transfer( origin: OriginFor<T>, source: <T::Lookup as StaticLookup>::Source, dest: <T::Lookup as StaticLookup>::Source, currency_id: T::CurrencyId, amount: T::Balance ) -> DispatchResultWithPostInfo
pub fn set_balance( origin: OriginFor<T>, who: <T::Lookup as StaticLookup>::Source, currency_id: T::CurrencyId, new_free: T::Balance, new_reserved: T::Balance ) -> DispatchResultWithPostInfo
Trait Implementations§
source§impl<T: Config> BeforeAllRuntimeMigrations for Pallet<T>
impl<T: Config> BeforeAllRuntimeMigrations for Pallet<T>
source§fn before_all_runtime_migrations() -> Weight
fn before_all_runtime_migrations() -> Weight
Something that should happen before runtime migrations are executed.
source§impl<T: Config> Currency<<T as Config>::AccountId> for Pallet<T>
impl<T: Config> Currency<<T as Config>::AccountId> for Pallet<T>
§type NegativeImbalance = <<T as Config>::NativeFungible as Currency<<T as Config>::AccountId>>::NegativeImbalance
type NegativeImbalance = <<T as Config>::NativeFungible as Currency<<T as Config>::AccountId>>::NegativeImbalance
The opaque token type for an imbalance. This is returned by unbalanced operations
and must be dealt with. It may be dropped but cannot be cloned.
§type PositiveImbalance = <<T as Config>::NativeFungible as Currency<<T as Config>::AccountId>>::PositiveImbalance
type PositiveImbalance = <<T as Config>::NativeFungible as Currency<<T as Config>::AccountId>>::PositiveImbalance
The opaque token type for an imbalance. This is returned by unbalanced operations
and must be dealt with. It may be dropped but cannot be cloned.
source§fn total_balance(who: &T::AccountId) -> Self::Balance
fn total_balance(who: &T::AccountId) -> Self::Balance
The combined balance of
who
.source§fn can_slash(who: &T::AccountId, value: Self::Balance) -> bool
fn can_slash(who: &T::AccountId, value: Self::Balance) -> bool
Same result as
slash(who, value)
(but without the side-effects) assuming there are no
balance changes in the meantime and only the reserved balance is not taken into account.source§fn total_issuance() -> Self::Balance
fn total_issuance() -> Self::Balance
The total amount of issuance in the system.
source§fn minimum_balance() -> Self::Balance
fn minimum_balance() -> Self::Balance
The minimum balance any single account may have. This is equivalent to the
Balances
module’s ExistentialDeposit
.source§fn burn(amount: Self::Balance) -> Self::PositiveImbalance
fn burn(amount: Self::Balance) -> Self::PositiveImbalance
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 issue(amount: Self::Balance) -> Self::NegativeImbalance
fn issue(amount: Self::Balance) -> Self::NegativeImbalance
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 free_balance(who: &T::AccountId) -> Self::Balance
fn free_balance(who: &T::AccountId) -> Self::Balance
The ‘free’ balance of a given account. Read more
source§fn ensure_can_withdraw(
who: &T::AccountId,
_amount: Self::Balance,
reasons: WithdrawReasons,
new_balance: Self::Balance
) -> DispatchResult
fn ensure_can_withdraw( who: &T::AccountId, _amount: Self::Balance, reasons: WithdrawReasons, new_balance: Self::Balance ) -> DispatchResult
Returns
Ok
iff the account is able to make a withdrawal of the given amount
for the given reason. Basically, it’s just a dry-run of withdraw
. Read moresource§fn transfer(
source: &T::AccountId,
dest: &T::AccountId,
value: Self::Balance,
existence_requirement: ExistenceRequirement
) -> DispatchResult
fn transfer( source: &T::AccountId, dest: &T::AccountId, value: Self::Balance, existence_requirement: ExistenceRequirement ) -> DispatchResult
Transfer some liquid free balance to another staker. Read more
source§fn slash(
who: &T::AccountId,
value: Self::Balance
) -> (Self::NegativeImbalance, Self::Balance)
fn slash( who: &T::AccountId, value: Self::Balance ) -> (Self::NegativeImbalance, Self::Balance)
Deducts up to
value
from the combined balance of who
, preferring to deduct from the
free balance. This function cannot fail. Read moresource§fn deposit_into_existing(
who: &T::AccountId,
value: Self::Balance
) -> Result<Self::PositiveImbalance, DispatchError>
fn deposit_into_existing( who: &T::AccountId, value: Self::Balance ) -> Result<Self::PositiveImbalance, DispatchError>
source§fn deposit_creating(
who: &T::AccountId,
value: Self::Balance
) -> Self::PositiveImbalance
fn deposit_creating( who: &T::AccountId, value: Self::Balance ) -> Self::PositiveImbalance
source§fn withdraw(
who: &T::AccountId,
value: Self::Balance,
reasons: WithdrawReasons,
liveness: ExistenceRequirement
) -> Result<Self::NegativeImbalance, DispatchError>
fn withdraw( who: &T::AccountId, value: Self::Balance, reasons: WithdrawReasons, liveness: ExistenceRequirement ) -> Result<Self::NegativeImbalance, DispatchError>
Removes some free balance from
who
account for reason
if possible. If liveness
is
KeepAlive
, then no less than ExistentialDeposit
must be left remaining. Read moresource§fn make_free_balance_be(
who: &T::AccountId,
balance: Self::Balance
) -> SignedImbalance<Self::Balance, Self::PositiveImbalance>
fn make_free_balance_be( who: &T::AccountId, balance: Self::Balance ) -> SignedImbalance<Self::Balance, Self::PositiveImbalance>
Ensure an account’s free balance equals some value; this will create the account
if needed. Read more
§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.
§fn deactivate(_: Self::Balance)
fn deactivate(_: Self::Balance)
Reduce the active issuance by some amount.
§fn reactivate(_: Self::Balance)
fn reactivate(_: Self::Balance)
Increase the active issuance by some amount, up to the outstanding amount reduced.
§fn pair(
amount: Self::Balance
) -> (Self::PositiveImbalance, Self::NegativeImbalance)
fn pair( amount: Self::Balance ) -> (Self::PositiveImbalance, Self::NegativeImbalance)
Produce a pair of imbalances that cancel each other out exactly. Read more
§fn resolve_into_existing(
who: &AccountId,
value: Self::NegativeImbalance
) -> Result<(), Self::NegativeImbalance>
fn resolve_into_existing( who: &AccountId, value: Self::NegativeImbalance ) -> Result<(), Self::NegativeImbalance>
Similar to deposit_creating, only accepts a
NegativeImbalance
and returns nothing on
success.§fn resolve_creating(who: &AccountId, value: Self::NegativeImbalance)
fn resolve_creating(who: &AccountId, value: Self::NegativeImbalance)
Similar to deposit_creating, only accepts a
NegativeImbalance
and returns nothing on
success.§fn settle(
who: &AccountId,
value: Self::PositiveImbalance,
reasons: WithdrawReasons,
liveness: ExistenceRequirement
) -> Result<(), Self::PositiveImbalance>
fn settle( who: &AccountId, value: Self::PositiveImbalance, reasons: WithdrawReasons, liveness: ExistenceRequirement ) -> Result<(), Self::PositiveImbalance>
Similar to withdraw, only accepts a
PositiveImbalance
and returns nothing on success.source§impl<T: Config> GetStorageVersion for Pallet<T>
impl<T: Config> GetStorageVersion for Pallet<T>
§type CurrentStorageVersion = NoStorageVersionSet
type CurrentStorageVersion = NoStorageVersionSet
source§fn current_storage_version() -> Self::CurrentStorageVersion
fn current_storage_version() -> Self::CurrentStorageVersion
Returns the current storage version as supported by the pallet.
source§fn on_chain_storage_version() -> StorageVersion
fn on_chain_storage_version() -> StorageVersion
Returns the on-chain storage version of the pallet as stored in the storage.
source§impl<T: Config> Hooks<<<<T as Config>::Block as HeaderProvider>::HeaderT as Header>::Number> for Pallet<T>
impl<T: Config> Hooks<<<<T as Config>::Block as HeaderProvider>::HeaderT as Header>::Number> for Pallet<T>
§fn on_initialize(_n: BlockNumber) -> Weight
fn on_initialize(_n: BlockNumber) -> Weight
Block initialization hook. This is called at the very beginning of block execution. Read more
§fn on_finalize(_n: BlockNumber)
fn on_finalize(_n: BlockNumber)
Block finalization hook. This is called at the very end of block execution. Read more
§fn on_idle(_n: BlockNumber, _remaining_weight: Weight) -> Weight
fn on_idle(_n: BlockNumber, _remaining_weight: Weight) -> Weight
Hook to consume a block’s idle time. This will run when the block is being finalized (before
[
Hooks::on_finalize
]). Read more§fn on_runtime_upgrade() -> Weight
fn on_runtime_upgrade() -> Weight
Hook executed when a code change (aka. a “runtime upgrade”) is detected by FRAME. Read more
§fn offchain_worker(_n: BlockNumber)
fn offchain_worker(_n: BlockNumber)
Implementing this function on a pallet allows you to perform long-running tasks that are
dispatched as separate threads, and entirely independent of the main wasm runtime. Read more
§fn integrity_test()
fn integrity_test()
Check the integrity of this pallet’s configuration. Read more
source§impl<T: Config> Inspect<<T as Config>::AccountId> for Pallet<T>
impl<T: Config> Inspect<<T as Config>::AccountId> for Pallet<T>
§type AssetId = <T as Config>::CurrencyId
type AssetId = <T as Config>::CurrencyId
Means of identifying one asset class from another.
source§fn total_issuance(asset: Self::AssetId) -> Self::Balance
fn total_issuance(asset: Self::AssetId) -> Self::Balance
The total amount of issuance in the system.
source§fn minimum_balance(asset: Self::AssetId) -> Self::Balance
fn minimum_balance(asset: Self::AssetId) -> Self::Balance
The minimum balance any single account may have.
source§fn total_balance(asset: Self::AssetId, who: &T::AccountId) -> Self::Balance
fn total_balance(asset: Self::AssetId, who: &T::AccountId) -> Self::Balance
Get the total amount of funds whose ultimate beneficial ownership can be determined as
who
. Read moresource§fn balance(asset: Self::AssetId, who: &T::AccountId) -> Self::Balance
fn balance(asset: Self::AssetId, who: &T::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 reducible_balance(
asset: Self::AssetId,
who: &T::AccountId,
preservation: Preservation,
force: Fortitude
) -> Self::Balance
fn reducible_balance( asset: Self::AssetId, who: &T::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
transfer and potentially go below user-level restrictions on the minimum amount of the
account. Read moresource§fn can_deposit(
asset: Self::AssetId,
who: &T::AccountId,
amount: Self::Balance,
provenance: Provenance
) -> DepositConsequence
fn can_deposit( asset: Self::AssetId, who: &T::AccountId, amount: Self::Balance, provenance: Provenance ) -> DepositConsequence
source§fn can_withdraw(
asset: Self::AssetId,
who: &T::AccountId,
amount: Self::Balance
) -> WithdrawConsequence<Self::Balance>
fn can_withdraw( asset: Self::AssetId, who: &T::AccountId, amount: Self::Balance ) -> WithdrawConsequence<Self::Balance>
Returns
Failed
if the asset
balance of who
may not be decreased by amount
, otherwise
the consequence.source§fn asset_exists(asset: Self::AssetId) -> bool
fn asset_exists(asset: Self::AssetId) -> bool
Returns
true
if an asset
exists.§fn active_issuance(asset: Self::AssetId) -> Self::Balance
fn active_issuance(asset: Self::AssetId) -> Self::Balance
The total amount of issuance in the system excluding those which are controlled by the
system.
source§impl<T: Config> Inspect<<T as Config>::AccountId> for Pallet<T>
impl<T: Config> Inspect<<T as Config>::AccountId> for Pallet<T>
source§fn total_issuance() -> Self::Balance
fn total_issuance() -> Self::Balance
The total amount of issuance in the system.
source§fn minimum_balance() -> Self::Balance
fn minimum_balance() -> Self::Balance
The minimum balance any single account may have.
source§fn total_balance(who: &T::AccountId) -> Self::Balance
fn total_balance(who: &T::AccountId) -> Self::Balance
Get the total amount of funds whose ultimate beneficial ownership can be determined as
who
. Read moresource§fn balance(who: &T::AccountId) -> Self::Balance
fn balance(who: &T::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 reducible_balance(
who: &T::AccountId,
preservation: Preservation,
force: Fortitude
) -> Self::Balance
fn reducible_balance( who: &T::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: &T::AccountId,
amount: Self::Balance,
provenance: Provenance
) -> DepositConsequence
fn can_deposit( who: &T::AccountId, amount: Self::Balance, provenance: Provenance ) -> DepositConsequence
source§fn can_withdraw(
who: &T::AccountId,
amount: Self::Balance
) -> WithdrawConsequence<Self::Balance>
fn can_withdraw( who: &T::AccountId, amount: Self::Balance ) -> WithdrawConsequence<Self::Balance>
Returns
Success
if the balance of who
may be decreased by amount
, otherwise
the consequence.§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§impl<T: Config> Inspect<<T as Config>::AccountId> for Pallet<T>
impl<T: Config> Inspect<<T as Config>::AccountId> for Pallet<T>
§type Reason = <T as Config>::RuntimeHoldReason
type Reason = <T as Config>::RuntimeHoldReason
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 total_balance_on_hold(who: &T::AccountId) -> Self::Balance
fn total_balance_on_hold(who: &T::AccountId) -> Self::Balance
Amount of funds on hold (for all hold reasons) of
who
.source§fn reducible_total_balance_on_hold(
who: &T::AccountId,
force: Fortitude
) -> Self::Balance
fn reducible_total_balance_on_hold( who: &T::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 balance_on_hold(reason: &Self::Reason, who: &T::AccountId) -> Self::Balance
fn balance_on_hold(reason: &Self::Reason, who: &T::AccountId) -> Self::Balance
Amount of funds on hold (for the given reason) of
who
.source§fn hold_available(reason: &Self::Reason, who: &T::AccountId) -> bool
fn hold_available(reason: &Self::Reason, who: &T::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 can_hold(
reason: &Self::Reason,
who: &T::AccountId,
amount: Self::Balance
) -> bool
fn can_hold( reason: &Self::Reason, who: &T::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 more§fn ensure_can_hold(
reason: &Self::Reason,
who: &AccountId,
amount: Self::Balance
) -> Result<(), DispatchError>
fn ensure_can_hold( reason: &Self::Reason, who: &AccountId, amount: Self::Balance ) -> Result<(), DispatchError>
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<T: Config> Inspect<<T as Config>::AccountId> for Pallet<T>
impl<T: Config> Inspect<<T as Config>::AccountId> for Pallet<T>
§type Reason = ()
type 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 total_balance_on_hold(
asset: Self::AssetId,
who: &T::AccountId
) -> Self::Balance
fn total_balance_on_hold( asset: Self::AssetId, who: &T::AccountId ) -> Self::Balance
Amount of funds on hold (for all hold reasons) of
who
.source§fn reducible_total_balance_on_hold(
asset: Self::AssetId,
who: &T::AccountId,
force: Fortitude
) -> Self::Balance
fn reducible_total_balance_on_hold( asset: Self::AssetId, who: &T::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 balance_on_hold(
asset: Self::AssetId,
_reason: &Self::Reason,
who: &T::AccountId
) -> Self::Balance
fn balance_on_hold( asset: Self::AssetId, _reason: &Self::Reason, who: &T::AccountId ) -> Self::Balance
Amount of funds on hold (for the given reason) of
who
.source§fn hold_available(
asset: Self::AssetId,
_reason: &Self::Reason,
who: &T::AccountId
) -> bool
fn hold_available( asset: Self::AssetId, _reason: &Self::Reason, who: &T::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 can_hold(
asset: Self::AssetId,
_reason: &Self::Reason,
who: &T::AccountId,
amount: Self::Balance
) -> bool
fn can_hold( asset: Self::AssetId, _reason: &Self::Reason, who: &T::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 more§fn ensure_can_hold(
asset: Self::AssetId,
reason: &Self::Reason,
who: &AccountId,
amount: Self::Balance
) -> Result<(), DispatchError>
fn ensure_can_hold( asset: Self::AssetId, reason: &Self::Reason, who: &AccountId, amount: Self::Balance ) -> Result<(), DispatchError>
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<T: Config> IntegrityTest for Pallet<T>
impl<T: Config> IntegrityTest for Pallet<T>
source§fn integrity_test()
fn integrity_test()
See [
Hooks::integrity_test
].source§impl<T: Config> LockableCurrency<<T as Config>::AccountId> for Pallet<T>
impl<T: Config> LockableCurrency<<T as Config>::AccountId> for Pallet<T>
§type MaxLocks = <<T as Config>::NativeFungible as LockableCurrency<<T as Config>::AccountId>>::MaxLocks
type MaxLocks = <<T as Config>::NativeFungible as LockableCurrency<<T as Config>::AccountId>>::MaxLocks
The maximum number of locks a user should have on their account.
§type Moment = <<T as Config>::NativeFungible as LockableCurrency<<T as Config>::AccountId>>::Moment
type Moment = <<T as Config>::NativeFungible as LockableCurrency<<T as Config>::AccountId>>::Moment
The quantity used to denote time; usually just a
BlockNumber
.source§fn set_lock(
id: LockIdentifier,
who: &T::AccountId,
amount: Self::Balance,
reasons: WithdrawReasons
)
fn set_lock( id: LockIdentifier, who: &T::AccountId, amount: Self::Balance, reasons: WithdrawReasons )
Create a new balance lock on account
who
. Read moresource§fn extend_lock(
id: LockIdentifier,
who: &T::AccountId,
amount: Self::Balance,
reasons: WithdrawReasons
)
fn extend_lock( id: LockIdentifier, who: &T::AccountId, amount: Self::Balance, reasons: WithdrawReasons )
Changes a balance lock (selected by
id
) so that it becomes less liquid in all
parameters or creates a new one if it does not exist. Read moresource§fn remove_lock(id: LockIdentifier, who: &T::AccountId)
fn remove_lock(id: LockIdentifier, who: &T::AccountId)
Remove an existing lock.
source§impl<T: Config> Mutate<<T as Config>::AccountId> for Pallet<T>
impl<T: Config> Mutate<<T as Config>::AccountId> for Pallet<T>
source§fn mint_into(
who: &T::AccountId,
amount: Self::Balance
) -> Result<Self::Balance, DispatchError>
fn mint_into( who: &T::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: &T::AccountId,
amount: Self::Balance,
precision: Precision,
force: Fortitude
) -> Result<Self::Balance, DispatchError>
fn burn_from( who: &T::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 transfer(
source: &T::AccountId,
dest: &T::AccountId,
amount: Self::Balance,
preservation: Preservation
) -> Result<Self::Balance, DispatchError>
fn transfer( source: &T::AccountId, dest: &T::AccountId, amount: Self::Balance, preservation: Preservation ) -> Result<Self::Balance, DispatchError>
Transfer funds from one account into another. Read more
§fn shelve(
who: &AccountId,
amount: Self::Balance
) -> Result<Self::Balance, DispatchError>
fn shelve( who: &AccountId, amount: Self::Balance ) -> Result<Self::Balance, DispatchError>
§fn restore(
who: &AccountId,
amount: Self::Balance
) -> Result<Self::Balance, DispatchError>
fn restore( who: &AccountId, amount: Self::Balance ) -> Result<Self::Balance, DispatchError>
§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<T: Config> Mutate<<T as Config>::AccountId> for Pallet<T>
impl<T: Config> Mutate<<T as Config>::AccountId> for Pallet<T>
source§fn mint_into(
asset: Self::AssetId,
who: &T::AccountId,
amount: Self::Balance
) -> Result<Self::Balance, DispatchError>
fn mint_into( asset: Self::AssetId, who: &T::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(
asset: Self::AssetId,
who: &T::AccountId,
amount: Self::Balance,
precision: Precision,
force: Fortitude
) -> Result<Self::Balance, DispatchError>
fn burn_from( asset: Self::AssetId, who: &T::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 transfer(
asset: Self::AssetId,
source: &T::AccountId,
dest: &T::AccountId,
amount: Self::Balance,
preservation: Preservation
) -> Result<Self::Balance, DispatchError>
fn transfer( asset: Self::AssetId, source: &T::AccountId, dest: &T::AccountId, amount: Self::Balance, preservation: Preservation ) -> Result<Self::Balance, DispatchError>
Transfer funds from one account into another. Read more
§fn shelve(
asset: Self::AssetId,
who: &AccountId,
amount: Self::Balance
) -> Result<Self::Balance, DispatchError>
fn shelve( asset: Self::AssetId, who: &AccountId, amount: Self::Balance ) -> Result<Self::Balance, DispatchError>
§fn restore(
asset: Self::AssetId,
who: &AccountId,
amount: Self::Balance
) -> Result<Self::Balance, DispatchError>
fn restore( asset: Self::AssetId, who: &AccountId, amount: Self::Balance ) -> Result<Self::Balance, DispatchError>
§fn set_balance(
asset: Self::AssetId,
who: &AccountId,
amount: Self::Balance
) -> Self::Balance
fn set_balance( asset: Self::AssetId, 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( _asset: Self::AssetId, _who: &AccountId, _amount: Self::Balance )
fn done_burn_from( _asset: Self::AssetId, _who: &AccountId, _amount: Self::Balance )
fn done_shelve(_asset: Self::AssetId, _who: &AccountId, _amount: Self::Balance)
fn done_restore(_asset: Self::AssetId, _who: &AccountId, _amount: Self::Balance)
fn done_transfer( _asset: Self::AssetId, _source: &AccountId, _dest: &AccountId, _amount: Self::Balance )
source§impl<T: Config> Mutate<<T as Config>::AccountId> for Pallet<T>
impl<T: Config> Mutate<<T as Config>::AccountId> for Pallet<T>
source§fn hold(
reason: &Self::Reason,
who: &T::AccountId,
amount: Self::Balance
) -> DispatchResult
fn hold( reason: &Self::Reason, who: &T::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: &T::AccountId,
amount: Self::Balance,
precision: Precision
) -> Result<Self::Balance, DispatchError>
fn release( reason: &Self::Reason, who: &T::AccountId, amount: Self::Balance, precision: Precision ) -> Result<Self::Balance, DispatchError>
Release up to
amount
held funds in an account. Read moresource§fn transfer_on_hold(
reason: &Self::Reason,
source: &T::AccountId,
dest: &T::AccountId,
amount: Self::Balance,
precision: Precision,
mode: Restriction,
force: Fortitude
) -> Result<Self::Balance, DispatchError>
fn transfer_on_hold( reason: &Self::Reason, source: &T::AccountId, dest: &T::AccountId, amount: Self::Balance, precision: Precision, mode: Restriction, force: Fortitude ) -> Result<Self::Balance, DispatchError>
Transfer held funds into a destination account. Read more
§fn set_on_hold(
reason: &Self::Reason,
who: &AccountId,
amount: Self::Balance
) -> Result<(), DispatchError>
fn set_on_hold( reason: &Self::Reason, who: &AccountId, amount: Self::Balance ) -> Result<(), DispatchError>
Hold or release funds in the account of
who
to bring the balance on hold for reason
to
exactly amount
.§fn release_all(
reason: &Self::Reason,
who: &AccountId,
precision: Precision
) -> Result<Self::Balance, DispatchError>
fn release_all( reason: &Self::Reason, who: &AccountId, precision: Precision ) -> Result<Self::Balance, DispatchError>
§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>
§fn burn_all_held(
reason: &Self::Reason,
who: &AccountId,
precision: Precision,
force: Fortitude
) -> Result<Self::Balance, DispatchError>
fn burn_all_held( reason: &Self::Reason, who: &AccountId, precision: Precision, force: Fortitude ) -> Result<Self::Balance, DispatchError>
§fn transfer_and_hold(
reason: &Self::Reason,
source: &AccountId,
dest: &AccountId,
amount: Self::Balance,
precision: Precision,
expendability: Preservation,
force: Fortitude
) -> Result<Self::Balance, DispatchError>
fn transfer_and_hold( reason: &Self::Reason, source: &AccountId, dest: &AccountId, amount: Self::Balance, precision: Precision, expendability: 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<T: Config> Mutate<<T as Config>::AccountId> for Pallet<T>
impl<T: Config> Mutate<<T as Config>::AccountId> for Pallet<T>
source§fn hold(
asset: Self::AssetId,
_reason: &Self::Reason,
who: &T::AccountId,
amount: Self::Balance
) -> DispatchResult
fn hold( asset: Self::AssetId, _reason: &Self::Reason, who: &T::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(
asset: Self::AssetId,
_reason: &Self::Reason,
who: &T::AccountId,
amount: Self::Balance,
precision: Precision
) -> Result<Self::Balance, DispatchError>
fn release( asset: Self::AssetId, _reason: &Self::Reason, who: &T::AccountId, amount: Self::Balance, precision: Precision ) -> Result<Self::Balance, DispatchError>
Release up to
amount
held funds in an account. Read moresource§fn transfer_on_hold(
asset: Self::AssetId,
_reason: &Self::Reason,
source: &T::AccountId,
dest: &T::AccountId,
amount: Self::Balance,
precision: Precision,
mode: Restriction,
force: Fortitude
) -> Result<Self::Balance, DispatchError>
fn transfer_on_hold( asset: Self::AssetId, _reason: &Self::Reason, source: &T::AccountId, dest: &T::AccountId, amount: Self::Balance, precision: Precision, mode: Restriction, force: Fortitude ) -> Result<Self::Balance, DispatchError>
Transfer held funds into a destination account. Read more
§fn burn_held(
asset: Self::AssetId,
reason: &Self::Reason,
who: &AccountId,
amount: Self::Balance,
precision: Precision,
force: Fortitude
) -> Result<Self::Balance, DispatchError>
fn burn_held( asset: Self::AssetId, reason: &Self::Reason, who: &AccountId, amount: Self::Balance, precision: Precision, force: Fortitude ) -> Result<Self::Balance, DispatchError>
Attempt to decrease the
asset
balance of who
which is held for the given reason
by
amount
. Read more§fn burn_all_held(
asset: Self::AssetId,
reason: &Self::Reason,
who: &AccountId,
precision: Precision,
force: Fortitude
) -> Result<Self::Balance, DispatchError>
fn burn_all_held( asset: Self::AssetId, reason: &Self::Reason, who: &AccountId, precision: Precision, force: Fortitude ) -> Result<Self::Balance, DispatchError>
§fn transfer_and_hold(
asset: Self::AssetId,
reason: &Self::Reason,
source: &AccountId,
dest: &AccountId,
amount: Self::Balance,
precision: Precision,
expendability: Preservation,
force: Fortitude
) -> Result<Self::Balance, DispatchError>
fn transfer_and_hold( asset: Self::AssetId, reason: &Self::Reason, source: &AccountId, dest: &AccountId, amount: Self::Balance, precision: Precision, expendability: 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
.
for reason
. Read morefn done_hold( _asset: Self::AssetId, _reason: &Self::Reason, _who: &AccountId, _amount: Self::Balance )
fn done_release( _asset: Self::AssetId, _reason: &Self::Reason, _who: &AccountId, _amount: Self::Balance )
fn done_burn_held( _asset: Self::AssetId, _reason: &Self::Reason, _who: &AccountId, _amount: Self::Balance )
fn done_transfer_on_hold( _asset: Self::AssetId, _reason: &Self::Reason, _source: &AccountId, _dest: &AccountId, _amount: Self::Balance )
fn done_transfer_and_hold( _asset: Self::AssetId, _reason: &Self::Reason, _source: &AccountId, _dest: &AccountId, _transferred: Self::Balance )
source§impl<T: Config> OffchainWorker<<<<T as Config>::Block as HeaderProvider>::HeaderT as Header>::Number> for Pallet<T>
impl<T: Config> OffchainWorker<<<<T as Config>::Block as HeaderProvider>::HeaderT as Header>::Number> for Pallet<T>
source§fn offchain_worker(n: BlockNumberFor<T>)
fn offchain_worker(n: BlockNumberFor<T>)
This function is being called after every block import (when fully synced). Read more
source§impl<T: Config> OnFinalize<<<<T as Config>::Block as HeaderProvider>::HeaderT as Header>::Number> for Pallet<T>
impl<T: Config> OnFinalize<<<<T as Config>::Block as HeaderProvider>::HeaderT as Header>::Number> for Pallet<T>
source§fn on_finalize(n: BlockNumberFor<T>)
fn on_finalize(n: BlockNumberFor<T>)
See [
Hooks::on_finalize
].source§impl<T: Config> OnGenesis for Pallet<T>
impl<T: Config> OnGenesis for Pallet<T>
source§fn on_genesis()
fn on_genesis()
Something that should happen at genesis.
source§impl<T: Config> OnIdle<<<<T as Config>::Block as HeaderProvider>::HeaderT as Header>::Number> for Pallet<T>
impl<T: Config> OnIdle<<<<T as Config>::Block as HeaderProvider>::HeaderT as Header>::Number> for Pallet<T>
source§impl<T: Config> OnInitialize<<<<T as Config>::Block as HeaderProvider>::HeaderT as Header>::Number> for Pallet<T>
impl<T: Config> OnInitialize<<<<T as Config>::Block as HeaderProvider>::HeaderT as Header>::Number> for Pallet<T>
source§fn on_initialize(n: BlockNumberFor<T>) -> Weight
fn on_initialize(n: BlockNumberFor<T>) -> Weight
See [
Hooks::on_initialize
].source§impl<T: Config> OnRuntimeUpgrade for Pallet<T>
impl<T: Config> OnRuntimeUpgrade for Pallet<T>
source§fn on_runtime_upgrade() -> Weight
fn on_runtime_upgrade() -> Weight
See [
Hooks::on_runtime_upgrade
].source§impl<T: Config> PalletInfoAccess for Pallet<T>
impl<T: Config> PalletInfoAccess for Pallet<T>
source§fn module_name() -> &'static str
fn module_name() -> &'static str
Name of the Rust module containing the pallet.
source§fn crate_version() -> CrateVersion
fn crate_version() -> CrateVersion
Version of the crate containing the pallet.
source§impl<T> PartialEq for Pallet<T>
impl<T> PartialEq for Pallet<T>
source§impl<T: Config> ReservableCurrency<<T as Config>::AccountId> for Pallet<T>
impl<T: Config> ReservableCurrency<<T as Config>::AccountId> for Pallet<T>
source§fn can_reserve(who: &T::AccountId, value: Self::Balance) -> bool
fn can_reserve(who: &T::AccountId, value: Self::Balance) -> bool
Same result as
reserve(who, value)
(but without the side-effects) assuming there
are no balance changes in the meantime.source§fn slash_reserved(
who: &T::AccountId,
value: Self::Balance
) -> (Self::NegativeImbalance, Self::Balance)
fn slash_reserved( who: &T::AccountId, value: Self::Balance ) -> (Self::NegativeImbalance, Self::Balance)
source§fn reserved_balance(who: &T::AccountId) -> Self::Balance
fn reserved_balance(who: &T::AccountId) -> Self::Balance
The amount of the balance of a given account that is externally reserved; this can still get
slashed, but gets slashed last of all. Read more
source§fn reserve(who: &T::AccountId, value: Self::Balance) -> DispatchResult
fn reserve(who: &T::AccountId, value: Self::Balance) -> DispatchResult
Moves
value
from balance to reserved balance. Read moresource§fn unreserve(who: &T::AccountId, value: Self::Balance) -> Self::Balance
fn unreserve(who: &T::AccountId, value: Self::Balance) -> Self::Balance
Moves up to
value
from reserved balance to free balance. This function cannot fail. Read moresource§fn repatriate_reserved(
slashed: &T::AccountId,
beneficiary: &T::AccountId,
value: Self::Balance,
status: BalanceStatus
) -> Result<Self::Balance, DispatchError>
fn repatriate_reserved( slashed: &T::AccountId, beneficiary: &T::AccountId, value: Self::Balance, status: BalanceStatus ) -> Result<Self::Balance, DispatchError>
Moves up to
value
from reserved balance of account slashed
to balance of account
beneficiary
. beneficiary
must exist for this to succeed. If it does not, Err
will be
returned. Funds will be placed in either the free
balance or the reserved
balance,
depending on the status
. Read moresource§impl<T: Config> Unbalanced<<T as Config>::AccountId> for Pallet<T>
impl<T: Config> Unbalanced<<T as Config>::AccountId> for Pallet<T>
source§fn handle_dust(_dust: Dust<T::AccountId, Self>)
fn handle_dust(_dust: Dust<T::AccountId, Self>)
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(
asset: Self::AssetId,
who: &T::AccountId,
amount: Self::Balance
) -> Result<Option<Self::Balance>, DispatchError>
fn write_balance( asset: Self::AssetId, who: &T::AccountId, amount: Self::Balance ) -> Result<Option<Self::Balance>, DispatchError>
source§fn set_total_issuance(asset: Self::AssetId, amount: Self::Balance)
fn set_total_issuance(asset: Self::AssetId, amount: Self::Balance)
Set the total issuance to
amount
.§fn handle_raw_dust(asset: Self::AssetId, amount: Self::Balance)
fn handle_raw_dust(asset: Self::AssetId, 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 more§fn decrease_balance(
asset: Self::AssetId,
who: &AccountId,
amount: Self::Balance,
precision: Precision,
preservation: Preservation,
force: Fortitude
) -> Result<Self::Balance, DispatchError>
fn decrease_balance( asset: Self::AssetId, who: &AccountId, amount: Self::Balance, precision: Precision, preservation: Preservation, force: Fortitude ) -> Result<Self::Balance, DispatchError>
§fn increase_balance(
asset: Self::AssetId,
who: &AccountId,
amount: Self::Balance,
precision: Precision
) -> Result<Self::Balance, DispatchError>
fn increase_balance( asset: Self::AssetId, who: &AccountId, amount: Self::Balance, precision: Precision ) -> Result<Self::Balance, DispatchError>
§fn deactivate(_asset: Self::AssetId, _: Self::Balance)
fn deactivate(_asset: Self::AssetId, _: Self::Balance)
Reduce the active issuance by some amount.
§fn reactivate(_asset: Self::AssetId, _: Self::Balance)
fn reactivate(_asset: Self::AssetId, _: Self::Balance)
Increase the active issuance by some amount, up to the outstanding amount reduced.
source§impl<T: Config> Unbalanced<<T as Config>::AccountId> for Pallet<T>
impl<T: Config> Unbalanced<<T as Config>::AccountId> for Pallet<T>
source§fn handle_dust(_dust: Dust<T::AccountId, Self>)
fn handle_dust(_dust: Dust<T::AccountId, Self>)
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: &T::AccountId,
amount: Self::Balance
) -> Result<Option<Self::Balance>, DispatchError>
fn write_balance( who: &T::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
.§fn handle_raw_dust(amount: Self::Balance)
fn handle_raw_dust(amount: Self::Balance)
Create some dust and handle it with [
Unbalanced::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 [Inspect::minimum_balance()
] - 1`. Read more§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>
§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>
§fn deactivate(_: Self::Balance)
fn deactivate(_: Self::Balance)
Reduce the active issuance by some amount.
§fn reactivate(_: Self::Balance)
fn reactivate(_: Self::Balance)
Increase the active issuance by some amount, up to the outstanding amount reduced.
source§impl<T: Config> Unbalanced<<T as Config>::AccountId> for Pallet<T>
impl<T: Config> Unbalanced<<T as Config>::AccountId> for Pallet<T>
source§fn set_balance_on_hold(
reason: &Self::Reason,
who: &T::AccountId,
amount: Self::Balance
) -> DispatchResult
fn set_balance_on_hold( reason: &Self::Reason, who: &T::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 more§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>
§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>
source§impl<T: Config> Unbalanced<<T as Config>::AccountId> for Pallet<T>
impl<T: Config> Unbalanced<<T as Config>::AccountId> for Pallet<T>
source§fn set_balance_on_hold(
asset: Self::AssetId,
_reason: &Self::Reason,
who: &T::AccountId,
amount: Self::Balance
) -> DispatchResult
fn set_balance_on_hold( asset: Self::AssetId, _reason: &Self::Reason, who: &T::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 more§fn decrease_balance_on_hold(
asset: Self::AssetId,
reason: &Self::Reason,
who: &AccountId,
amount: Self::Balance,
precision: Precision
) -> Result<Self::Balance, DispatchError>
fn decrease_balance_on_hold( asset: Self::AssetId, reason: &Self::Reason, who: &AccountId, amount: Self::Balance, precision: Precision ) -> Result<Self::Balance, DispatchError>
§fn increase_balance_on_hold(
asset: Self::AssetId,
reason: &Self::Reason,
who: &AccountId,
amount: Self::Balance,
precision: Precision
) -> Result<Self::Balance, DispatchError>
fn increase_balance_on_hold( asset: Self::AssetId, reason: &Self::Reason, who: &AccountId, amount: Self::Balance, precision: Precision ) -> Result<Self::Balance, DispatchError>
source§impl<T: Config> WhitelistedStorageKeys for Pallet<T>
impl<T: Config> WhitelistedStorageKeys for Pallet<T>
source§fn whitelisted_storage_keys() -> Vec<TrackedStorageKey>
fn whitelisted_storage_keys() -> Vec<TrackedStorageKey>
Returns a
Vec<TrackedStorageKey>
indicating the storage keys that
should be whitelisted during benchmarking. This means that those keys
will be excluded from the benchmarking performance calculation.impl<T> Eq for Pallet<T>
Auto Trait Implementations§
impl<T> RefUnwindSafe for Pallet<T>where
T: RefUnwindSafe,
impl<T> Send for Pallet<T>where
T: Send,
impl<T> Sync for Pallet<T>where
T: Sync,
impl<T> Unpin for Pallet<T>where
T: Unpin,
impl<T> UnwindSafe for Pallet<T>where
T: UnwindSafe,
Blanket Implementations§
source§impl<T> BorrowMut<T> for Twhere
T: ?Sized,
impl<T> BorrowMut<T> for Twhere
T: ?Sized,
source§fn borrow_mut(&mut self) -> &mut T
fn borrow_mut(&mut self) -> &mut T
Mutably borrows from an owned value. Read more
§impl<T> CheckedConversion for T
impl<T> CheckedConversion for T
§fn checked_from<T>(t: T) -> Option<Self>where
Self: TryFrom<T>,
fn checked_from<T>(t: T) -> Option<Self>where
Self: TryFrom<T>,
§fn checked_into<T>(self) -> Option<T>where
Self: TryInto<T>,
fn checked_into<T>(self) -> Option<T>where
Self: TryInto<T>,
§impl<T> Conv for T
impl<T> Conv for T
source§impl<Q, K> Equivalent<K> for Q
impl<Q, K> Equivalent<K> for Q
source§fn equivalent(&self, key: &K) -> bool
fn equivalent(&self, key: &K) -> bool
Compare self to
key
and return true
if they are equal.§impl<Q, K> Equivalent<K> for Q
impl<Q, K> Equivalent<K> for Q
§fn equivalent(&self, key: &K) -> bool
fn equivalent(&self, key: &K) -> bool
Checks if this value is equivalent to the given key. Read more
§impl<T> FmtForward for T
impl<T> FmtForward for T
§fn fmt_binary(self) -> FmtBinary<Self>where
Self: Binary,
fn fmt_binary(self) -> FmtBinary<Self>where
Self: Binary,
Causes
self
to use its Binary
implementation when Debug
-formatted.§fn fmt_display(self) -> FmtDisplay<Self>where
Self: Display,
fn fmt_display(self) -> FmtDisplay<Self>where
Self: Display,
Causes
self
to use its Display
implementation when
Debug
-formatted.§fn fmt_lower_exp(self) -> FmtLowerExp<Self>where
Self: LowerExp,
fn fmt_lower_exp(self) -> FmtLowerExp<Self>where
Self: LowerExp,
Causes
self
to use its LowerExp
implementation when
Debug
-formatted.§fn fmt_lower_hex(self) -> FmtLowerHex<Self>where
Self: LowerHex,
fn fmt_lower_hex(self) -> FmtLowerHex<Self>where
Self: LowerHex,
Causes
self
to use its LowerHex
implementation when
Debug
-formatted.§fn fmt_octal(self) -> FmtOctal<Self>where
Self: Octal,
fn fmt_octal(self) -> FmtOctal<Self>where
Self: Octal,
Causes
self
to use its Octal
implementation when Debug
-formatted.§fn fmt_pointer(self) -> FmtPointer<Self>where
Self: Pointer,
fn fmt_pointer(self) -> FmtPointer<Self>where
Self: Pointer,
Causes
self
to use its Pointer
implementation when
Debug
-formatted.§fn fmt_upper_exp(self) -> FmtUpperExp<Self>where
Self: UpperExp,
fn fmt_upper_exp(self) -> FmtUpperExp<Self>where
Self: UpperExp,
Causes
self
to use its UpperExp
implementation when
Debug
-formatted.§fn fmt_upper_hex(self) -> FmtUpperHex<Self>where
Self: UpperHex,
fn fmt_upper_hex(self) -> FmtUpperHex<Self>where
Self: UpperHex,
Causes
self
to use its UpperHex
implementation when
Debug
-formatted.§fn fmt_list(self) -> FmtList<Self>where
&'a Self: for<'a> IntoIterator,
fn fmt_list(self) -> FmtList<Self>where
&'a Self: for<'a> IntoIterator,
Formats each item in a sequence. Read more
§impl<T> Instrument for T
impl<T> Instrument for T
§fn instrument(self, span: Span) -> Instrumented<Self>
fn instrument(self, span: Span) -> Instrumented<Self>
§fn in_current_span(self) -> Instrumented<Self>
fn in_current_span(self) -> Instrumented<Self>
source§impl<T> IntoEither for T
impl<T> IntoEither for T
source§fn into_either(self, into_left: bool) -> Either<Self, Self>
fn into_either(self, into_left: bool) -> Either<Self, Self>
Converts
self
into a Left
variant of Either<Self, Self>
if into_left
is true
.
Converts self
into a Right
variant of Either<Self, Self>
otherwise. Read moresource§fn into_either_with<F>(self, into_left: F) -> Either<Self, Self>
fn into_either_with<F>(self, into_left: F) -> Either<Self, Self>
Converts
self
into a Left
variant of Either<Self, Self>
if into_left(&self)
returns true
.
Converts self
into a Right
variant of Either<Self, Self>
otherwise. Read more§impl<T> IsType<T> for T
impl<T> IsType<T> for T
§impl<T, Outer> IsWrappedBy<Outer> for T
impl<T, Outer> IsWrappedBy<Outer> for T
§impl<T> Pipe for Twhere
T: ?Sized,
impl<T> Pipe for Twhere
T: ?Sized,
§fn pipe<R>(self, func: impl FnOnce(Self) -> R) -> Rwhere
Self: Sized,
fn pipe<R>(self, func: impl FnOnce(Self) -> R) -> Rwhere
Self: Sized,
Pipes by value. This is generally the method you want to use. Read more
§fn pipe_ref<'a, R>(&'a self, func: impl FnOnce(&'a Self) -> R) -> Rwhere
R: 'a,
fn pipe_ref<'a, R>(&'a self, func: impl FnOnce(&'a Self) -> R) -> Rwhere
R: 'a,
Borrows
self
and passes that borrow into the pipe function. Read more§fn pipe_ref_mut<'a, R>(&'a mut self, func: impl FnOnce(&'a mut Self) -> R) -> Rwhere
R: 'a,
fn pipe_ref_mut<'a, R>(&'a mut self, func: impl FnOnce(&'a mut Self) -> R) -> Rwhere
R: 'a,
Mutably borrows
self
and passes that borrow into the pipe function. Read more§fn pipe_borrow<'a, B, R>(&'a self, func: impl FnOnce(&'a B) -> R) -> R
fn pipe_borrow<'a, B, R>(&'a self, func: impl FnOnce(&'a B) -> R) -> R
§fn pipe_borrow_mut<'a, B, R>(
&'a mut self,
func: impl FnOnce(&'a mut B) -> R
) -> R
fn pipe_borrow_mut<'a, B, R>( &'a mut self, func: impl FnOnce(&'a mut B) -> R ) -> R
§fn pipe_as_ref<'a, U, R>(&'a self, func: impl FnOnce(&'a U) -> R) -> R
fn pipe_as_ref<'a, U, R>(&'a self, func: impl FnOnce(&'a U) -> R) -> R
Borrows
self
, then passes self.as_ref()
into the pipe function.§fn pipe_as_mut<'a, U, R>(&'a mut self, func: impl FnOnce(&'a mut U) -> R) -> R
fn pipe_as_mut<'a, U, R>(&'a mut self, func: impl FnOnce(&'a mut U) -> R) -> R
Mutably borrows
self
, then passes self.as_mut()
into the pipe
function.§fn pipe_deref<'a, T, R>(&'a self, func: impl FnOnce(&'a T) -> R) -> R
fn pipe_deref<'a, T, R>(&'a self, func: impl FnOnce(&'a T) -> R) -> R
Borrows
self
, then passes self.deref()
into the pipe function.§impl<T> Pointable for T
impl<T> Pointable for T
§impl<T> SaturatedConversion for T
impl<T> SaturatedConversion for T
§fn saturated_from<T>(t: T) -> Selfwhere
Self: UniqueSaturatedFrom<T>,
fn saturated_from<T>(t: T) -> Selfwhere
Self: UniqueSaturatedFrom<T>,
§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 more§impl<T> Tap for T
impl<T> Tap for T
§fn tap_borrow<B>(self, func: impl FnOnce(&B)) -> Self
fn tap_borrow<B>(self, func: impl FnOnce(&B)) -> Self
Immutable access to the
Borrow<B>
of a value. Read more§fn tap_borrow_mut<B>(self, func: impl FnOnce(&mut B)) -> Self
fn tap_borrow_mut<B>(self, func: impl FnOnce(&mut B)) -> Self
Mutable access to the
BorrowMut<B>
of a value. Read more§fn tap_ref<R>(self, func: impl FnOnce(&R)) -> Self
fn tap_ref<R>(self, func: impl FnOnce(&R)) -> Self
Immutable access to the
AsRef<R>
view of a value. Read more§fn tap_ref_mut<R>(self, func: impl FnOnce(&mut R)) -> Self
fn tap_ref_mut<R>(self, func: impl FnOnce(&mut R)) -> Self
Mutable access to the
AsMut<R>
view of a value. Read more§fn tap_deref<T>(self, func: impl FnOnce(&T)) -> Self
fn tap_deref<T>(self, func: impl FnOnce(&T)) -> Self
Immutable access to the
Deref::Target
of a value. Read more§fn tap_deref_mut<T>(self, func: impl FnOnce(&mut T)) -> Self
fn tap_deref_mut<T>(self, func: impl FnOnce(&mut T)) -> Self
Mutable access to the
Deref::Target
of a value. Read more§fn tap_dbg(self, func: impl FnOnce(&Self)) -> Self
fn tap_dbg(self, func: impl FnOnce(&Self)) -> Self
Calls
.tap()
only in debug builds, and is erased in release builds.§fn tap_mut_dbg(self, func: impl FnOnce(&mut Self)) -> Self
fn tap_mut_dbg(self, func: impl FnOnce(&mut Self)) -> Self
Calls
.tap_mut()
only in debug builds, and is erased in release
builds.§fn tap_borrow_dbg<B>(self, func: impl FnOnce(&B)) -> Self
fn tap_borrow_dbg<B>(self, func: impl FnOnce(&B)) -> Self
Calls
.tap_borrow()
only in debug builds, and is erased in release
builds.§fn tap_borrow_mut_dbg<B>(self, func: impl FnOnce(&mut B)) -> Self
fn tap_borrow_mut_dbg<B>(self, func: impl FnOnce(&mut B)) -> Self
Calls
.tap_borrow_mut()
only in debug builds, and is erased in release
builds.§fn tap_ref_dbg<R>(self, func: impl FnOnce(&R)) -> Self
fn tap_ref_dbg<R>(self, func: impl FnOnce(&R)) -> Self
Calls
.tap_ref()
only in debug builds, and is erased in release
builds.§fn tap_ref_mut_dbg<R>(self, func: impl FnOnce(&mut R)) -> Self
fn tap_ref_mut_dbg<R>(self, func: impl FnOnce(&mut R)) -> Self
Calls
.tap_ref_mut()
only in debug builds, and is erased in release
builds.§fn tap_deref_dbg<T>(self, func: impl FnOnce(&T)) -> Self
fn tap_deref_dbg<T>(self, func: impl FnOnce(&T)) -> Self
Calls
.tap_deref()
only in debug builds, and is erased in release
builds.§impl<T> TryConv for T
impl<T> TryConv for T
§impl<T, U> TryInto2<U> for Twhere
U: TryFrom2<T>,
impl<T, U> TryInto2<U> for Twhere
U: TryFrom2<T>,
§impl<S, T> UncheckedInto<T> for Swhere
T: UncheckedFrom<S>,
impl<S, T> UncheckedInto<T> for Swhere
T: UncheckedFrom<S>,
§fn unchecked_into(self) -> T
fn unchecked_into(self) -> T
The counterpart to
unchecked_from
.§impl<T, S> UniqueSaturatedInto<T> for S
impl<T, S> UniqueSaturatedInto<T> for S
§fn unique_saturated_into(self) -> T
fn unique_saturated_into(self) -> T
Consume self to return an equivalent value of
T
.