Struct fil_actor_miner_state::v14::State
source · pub struct State {Show 15 fields
pub info: Cid,
pub pre_commit_deposits: TokenAmount,
pub locked_funds: TokenAmount,
pub vesting_funds: Cid,
pub fee_debt: TokenAmount,
pub initial_pledge: TokenAmount,
pub pre_committed_sectors: Cid,
pub pre_committed_sectors_cleanup: Cid,
pub allocated_sectors: Cid,
pub sectors: Cid,
pub proving_period_start: ChainEpoch,
pub current_deadline: u64,
pub deadlines: Cid,
pub early_terminations: BitField,
pub deadline_cron_active: bool,
}
Expand description
Balance of Miner Actor should be greater than or equal to the sum of PreCommitDeposits and LockedFunds. It is possible for balance to fall below the sum of PCD, LF and InitialPledgeRequirements, and this is a bad state (IP Debt) that limits a miner actor’s behavior (i.e. no balance withdrawals) Excess balance as computed by st.GetAvailableBalance will be withdrawable or usable for pre-commit deposit or pledge lock-up.
Fields§
§info: Cid
Contains static info about this miner
pre_commit_deposits: TokenAmount
Total funds locked as pre_commit_deposit
locked_funds: TokenAmount
Total rewards and added funds locked in vesting table
vesting_funds: Cid
VestingFunds (Vesting Funds schedule for the miner).
fee_debt: TokenAmount
Absolute value of debt this miner owes from unpaid fees.
initial_pledge: TokenAmount
Sum of initial pledge requirements of all active sectors.
pre_committed_sectors: Cid
Sectors that have been pre-committed but not yet proven. Map, HAMT<SectorNumber, SectorPreCommitOnChainInfo>
pre_committed_sectors_cleanup: Cid
§allocated_sectors: Cid
Allocated sector IDs. Sector IDs can never be reused once allocated.
sectors: Cid
Information for all proven and not-yet-garbage-collected sectors.
Sectors are removed from this AMT when the partition to which the sector belongs is compacted.
proving_period_start: ChainEpoch
The first epoch in this miner’s current proving period. This is the first epoch in which a PoSt for a partition at the miner’s first deadline may arrive. Alternatively, it is after the last epoch at which a PoSt for the previous window is valid. Always greater than zero, this may be greater than the current epoch for genesis miners in the first WPoStProvingPeriod epochs of the chain; the epochs before the first proving period starts are exempt from Window PoSt requirements. Updated at the end of every period by a cron callback.
current_deadline: u64
Index of the deadline within the proving period beginning at ProvingPeriodStart that has not yet been finalized. Updated at the end of each deadline window by a cron callback.
deadlines: Cid
The sector numbers due for PoSt at each deadline in the current proving period, frozen at period start. New sectors are added and expired ones removed at proving period boundary. Faults are not subtracted from this in state, but on the fly.
early_terminations: BitField
Deadlines with outstanding fees for early sector termination.
deadline_cron_active: bool
Implementations§
source§impl State
impl State
pub fn new<BS: Blockstore>( policy: &Policy, store: &BS, info_cid: Cid, period_start: ChainEpoch, deadline_idx: u64, ) -> Result<Self, ActorError>
pub fn get_info<BS: Blockstore>(&self, store: &BS) -> Result<MinerInfo>
pub fn save_info<BS: Blockstore>( &mut self, store: &BS, info: &MinerInfo, ) -> Result<()>
sourcepub fn deadline_info(
&self,
policy: &Policy,
current_epoch: ChainEpoch,
) -> DeadlineInfo
pub fn deadline_info( &self, policy: &Policy, current_epoch: ChainEpoch, ) -> DeadlineInfo
Returns deadline calculations for the current (according to state) proving period.
pub fn recorded_deadline_info( &self, policy: &Policy, current_epoch: ChainEpoch, ) -> DeadlineInfo
pub fn current_proving_period_start( &self, policy: &Policy, current_epoch: ChainEpoch, ) -> ChainEpoch
sourcepub fn quant_spec_for_deadline(
&self,
policy: &Policy,
deadline_idx: u64,
) -> QuantSpec
pub fn quant_spec_for_deadline( &self, policy: &Policy, deadline_idx: u64, ) -> QuantSpec
Returns deadline calculations for the current (according to state) proving period.
sourcepub fn allocate_sector_numbers<BS: Blockstore>(
&mut self,
store: &BS,
sector_numbers: &BitField,
policy: CollisionPolicy,
) -> Result<(), ActorError>
pub fn allocate_sector_numbers<BS: Blockstore>( &mut self, store: &BS, sector_numbers: &BitField, policy: CollisionPolicy, ) -> Result<(), ActorError>
Marks a set of sector numbers as having been allocated.
If policy is DenyCollisions
, fails if the set intersects with the sector numbers already allocated.
sourcepub fn put_precommitted_sectors<BS: Blockstore>(
&mut self,
store: &BS,
precommits: Vec<SectorPreCommitOnChainInfo>,
) -> Result<()>
pub fn put_precommitted_sectors<BS: Blockstore>( &mut self, store: &BS, precommits: Vec<SectorPreCommitOnChainInfo>, ) -> Result<()>
Stores a pre-committed sector info, failing if the sector number is already present.
pub fn get_precommitted_sector<BS: Blockstore>( &self, store: &BS, sector_num: SectorNumber, ) -> Result<Option<SectorPreCommitOnChainInfo>, ActorError>
sourcepub fn find_precommitted_sectors<BS: Blockstore>(
&self,
store: &BS,
sector_numbers: &[SectorNumber],
) -> Result<Vec<SectorPreCommitOnChainInfo>>
pub fn find_precommitted_sectors<BS: Blockstore>( &self, store: &BS, sector_numbers: &[SectorNumber], ) -> Result<Vec<SectorPreCommitOnChainInfo>>
Gets and returns the requested pre-committed sectors, skipping missing sectors.
pub fn delete_precommitted_sectors<BS: Blockstore>( &mut self, store: &BS, sector_nums: &[SectorNumber], ) -> Result<(), ActorError>
pub fn has_sector_number<BS: Blockstore>( &self, store: &BS, sector_num: SectorNumber, ) -> Result<bool>
pub fn put_sectors<BS: Blockstore>( &mut self, store: &BS, new_sectors: Vec<SectorOnChainInfo>, ) -> Result<()>
pub fn get_sector<BS: Blockstore>( &self, store: &BS, sector_num: SectorNumber, ) -> Result<Option<SectorOnChainInfo>, ActorError>
pub fn delete_sectors<BS: Blockstore>( &mut self, store: &BS, sector_nos: &BitField, ) -> Result<(), AmtError>
pub fn for_each_sector<BS: Blockstore, F>(&self, store: &BS, f: F) -> Result<()>
sourcepub fn find_sector<BS: Blockstore>(
&self,
store: &BS,
sector_number: SectorNumber,
) -> Result<(u64, u64)>
pub fn find_sector<BS: Blockstore>( &self, store: &BS, sector_number: SectorNumber, ) -> Result<(u64, u64)>
Returns the deadline and partition index for a sector number.
sourcepub fn reschedule_sector_expirations<BS: Blockstore>(
&mut self,
policy: &Policy,
store: &BS,
current_epoch: ChainEpoch,
sector_size: SectorSize,
deadline_sectors: DeadlineSectorMap,
) -> Result<Vec<SectorOnChainInfo>>
pub fn reschedule_sector_expirations<BS: Blockstore>( &mut self, policy: &Policy, store: &BS, current_epoch: ChainEpoch, sector_size: SectorSize, deadline_sectors: DeadlineSectorMap, ) -> Result<Vec<SectorOnChainInfo>>
Schedules each sector to expire at its next deadline end. If it can’t find any given sector, it skips it.
This method assumes that each sector’s power has not changed, despite the rescheduling.
Note: this method is used to “upgrade” sectors, rescheduling the now-replaced sectors to expire at the end of the next deadline. Given the expense of sealing a sector, this function skips missing/faulty/terminated “upgraded” sectors instead of failing. That way, the new sectors can still be proved.
sourcepub fn assign_sectors_to_deadlines<BS: Blockstore>(
&mut self,
policy: &Policy,
store: &BS,
current_epoch: ChainEpoch,
sectors: Vec<SectorOnChainInfo>,
partition_size: u64,
sector_size: SectorSize,
) -> Result<()>
pub fn assign_sectors_to_deadlines<BS: Blockstore>( &mut self, policy: &Policy, store: &BS, current_epoch: ChainEpoch, sectors: Vec<SectorOnChainInfo>, partition_size: u64, sector_size: SectorSize, ) -> Result<()>
Assign new sectors to deadlines.
pub fn assign_sectors_to_deadline<BS: Blockstore>( &mut self, policy: &Policy, store: &BS, current_epoch: ChainEpoch, sectors: Vec<SectorOnChainInfo>, partition_size: u64, sector_size: SectorSize, deadline_idx: u64, ) -> Result<(), ActorError>
sourcepub fn pop_early_terminations<BS: Blockstore>(
&mut self,
policy: &Policy,
store: &BS,
max_partitions: u64,
max_sectors: u64,
) -> Result<(TerminationResult, bool)>
pub fn pop_early_terminations<BS: Blockstore>( &mut self, policy: &Policy, store: &BS, max_partitions: u64, max_sectors: u64, ) -> Result<(TerminationResult, bool)>
Pops up to max_sectors
early terminated sectors from all deadlines.
Returns true
if we still have more early terminations to process.
sourcepub fn check_sector_active<BS: Blockstore>(
&self,
store: &BS,
deadline_idx: u64,
partition_idx: u64,
sector_number: SectorNumber,
require_proven: bool,
) -> Result<bool, ActorError>
pub fn check_sector_active<BS: Blockstore>( &self, store: &BS, deadline_idx: u64, partition_idx: u64, sector_number: SectorNumber, require_proven: bool, ) -> Result<bool, ActorError>
Returns an error if the target sector cannot be found, or some other bad state is reached. Returns Ok(false) if the target sector is faulty, terminated, or unproven Returns Ok(true) otherwise
sourcepub fn check_sector_health<BS: Blockstore>(
&self,
store: &BS,
deadline_idx: u64,
partition_idx: u64,
sector_number: SectorNumber,
) -> Result<()>
pub fn check_sector_health<BS: Blockstore>( &self, store: &BS, deadline_idx: u64, partition_idx: u64, sector_number: SectorNumber, ) -> Result<()>
Returns an error if the target sector cannot be found and/or is faulty/terminated.
sourcepub fn load_sector_infos<BS: Blockstore>(
&self,
store: &BS,
sectors: &BitField,
) -> Result<Vec<SectorOnChainInfo>>
pub fn load_sector_infos<BS: Blockstore>( &self, store: &BS, sectors: &BitField, ) -> Result<Vec<SectorOnChainInfo>>
Loads sector info for a sequence of sectors.
pub fn load_deadlines<BS: Blockstore>( &self, store: &BS, ) -> Result<Deadlines, ActorError>
pub fn save_deadlines<BS: Blockstore>( &mut self, store: &BS, deadlines: Deadlines, ) -> Result<()>
sourcepub fn load_vesting_funds<BS: Blockstore>(
&self,
store: &BS,
) -> Result<VestingFunds>
pub fn load_vesting_funds<BS: Blockstore>( &self, store: &BS, ) -> Result<VestingFunds>
Loads the vesting funds table from the store.
sourcepub fn save_vesting_funds<BS: Blockstore>(
&mut self,
store: &BS,
funds: &VestingFunds,
) -> Result<()>
pub fn save_vesting_funds<BS: Blockstore>( &mut self, store: &BS, funds: &VestingFunds, ) -> Result<()>
Saves the vesting table to the store.
pub fn continue_deadline_cron(&self) -> bool
pub fn add_pre_commit_deposit(&mut self, amount: &TokenAmount) -> Result<()>
pub fn add_initial_pledge(&mut self, amount: &TokenAmount) -> Result<()>
pub fn apply_penalty(&mut self, penalty: &TokenAmount) -> Result<()>
sourcepub fn add_locked_funds<BS: Blockstore>(
&mut self,
store: &BS,
current_epoch: ChainEpoch,
vesting_sum: &TokenAmount,
spec: &VestSpec,
) -> Result<TokenAmount>
pub fn add_locked_funds<BS: Blockstore>( &mut self, store: &BS, current_epoch: ChainEpoch, vesting_sum: &TokenAmount, spec: &VestSpec, ) -> Result<TokenAmount>
First vests and unlocks the vested funds AND then locks the given funds in the vesting table.
sourcepub fn repay_partial_debt_in_priority_order<BS: Blockstore>(
&mut self,
store: &BS,
current_epoch: ChainEpoch,
curr_balance: &TokenAmount,
) -> Result<(TokenAmount, TokenAmount), Error>
pub fn repay_partial_debt_in_priority_order<BS: Blockstore>( &mut self, store: &BS, current_epoch: ChainEpoch, curr_balance: &TokenAmount, ) -> Result<(TokenAmount, TokenAmount), Error>
Draws from vesting table and unlocked funds to repay up to the fee debt. Returns the amount unlocked from the vesting table and the amount taken from current balance. If the fee debt exceeds the total amount available for repayment the fee debt field is updated to track the remaining debt. Otherwise it is set to zero.
sourcepub fn repay_debts(&mut self, curr_balance: &TokenAmount) -> Result<TokenAmount>
pub fn repay_debts(&mut self, curr_balance: &TokenAmount) -> Result<TokenAmount>
Repays the full miner actor fee debt. Returns the amount that must be burnt and an error if there are not sufficient funds to cover repayment. Miner state repays from unlocked funds and fails if unlocked funds are insufficient to cover fee debt. FeeDebt will be zero after a successful call.
sourcepub fn unlock_unvested_funds<BS: Blockstore>(
&mut self,
store: &BS,
current_epoch: ChainEpoch,
target: &TokenAmount,
) -> Result<TokenAmount>
pub fn unlock_unvested_funds<BS: Blockstore>( &mut self, store: &BS, current_epoch: ChainEpoch, target: &TokenAmount, ) -> Result<TokenAmount>
Unlocks an amount of funds that have not yet vested, if possible. The soonest-vesting entries are unlocked first. Returns the amount actually unlocked.
sourcepub fn unlock_vested_funds<BS: Blockstore>(
&mut self,
store: &BS,
current_epoch: ChainEpoch,
) -> Result<TokenAmount>
pub fn unlock_vested_funds<BS: Blockstore>( &mut self, store: &BS, current_epoch: ChainEpoch, ) -> Result<TokenAmount>
Unlocks all vesting funds that have vested before the provided epoch. Returns the amount unlocked.
sourcepub fn check_vested_funds<BS: Blockstore>(
&self,
store: &BS,
current_epoch: ChainEpoch,
) -> Result<TokenAmount>
pub fn check_vested_funds<BS: Blockstore>( &self, store: &BS, current_epoch: ChainEpoch, ) -> Result<TokenAmount>
CheckVestedFunds returns the amount of vested funds that have vested before the provided epoch.
sourcepub fn get_unlocked_balance(
&self,
actor_balance: &TokenAmount,
) -> Result<TokenAmount>
pub fn get_unlocked_balance( &self, actor_balance: &TokenAmount, ) -> Result<TokenAmount>
Unclaimed funds that are not locked – includes funds used to cover initial pledge requirement.
sourcepub fn get_available_balance(
&self,
actor_balance: &TokenAmount,
) -> Result<TokenAmount>
pub fn get_available_balance( &self, actor_balance: &TokenAmount, ) -> Result<TokenAmount>
Unclaimed funds. Actor balance - (locked funds, precommit deposit, ip requirement) Can go negative if the miner is in IP debt.
pub fn check_balance_invariants(&self, balance: &TokenAmount) -> Result<()>
sourcepub fn quant_spec_every_deadline(&self, policy: &Policy) -> QuantSpec
pub fn quant_spec_every_deadline(&self, policy: &Policy) -> QuantSpec
pre-commit expiry
pub fn add_pre_commit_clean_ups<BS: Blockstore>( &mut self, policy: &Policy, store: &BS, cleanup_events: Vec<(ChainEpoch, u64)>, ) -> Result<()>
pub fn cleanup_expired_pre_commits<BS: Blockstore>( &mut self, policy: &Policy, store: &BS, current_epoch: ChainEpoch, ) -> Result<TokenAmount>
pub fn advance_deadline<BS: Blockstore>( &mut self, policy: &Policy, store: &BS, current_epoch: ChainEpoch, ) -> Result<AdvanceDeadlineResult>
pub fn get_precommitted_sectors<BS: Blockstore>( &self, store: &BS, sector_nos: impl IntoIterator<Item = impl Borrow<SectorNumber>>, ) -> Result<Vec<SectorPreCommitOnChainInfo>, ActorError>
Trait Implementations§
source§impl<'de> Deserialize<'de> for State
impl<'de> Deserialize<'de> for State
source§fn deserialize<D>(deserializer: D) -> Result<Self, D::Error>where
D: Deserializer<'de>,
fn deserialize<D>(deserializer: D) -> Result<Self, D::Error>where
D: Deserializer<'de>,
Auto Trait Implementations§
impl Freeze for State
impl RefUnwindSafe for State
impl Send for State
impl Sync for State
impl Unpin for State
impl UnwindSafe for State
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
source§impl<T> CloneToUninit for Twhere
T: Clone,
impl<T> CloneToUninit for Twhere
T: Clone,
source§default unsafe fn clone_to_uninit(&self, dst: *mut T)
default unsafe fn clone_to_uninit(&self, dst: *mut T)
clone_to_uninit
)source§impl<T> FmtForward for T
impl<T> FmtForward for T
source§fn fmt_binary(self) -> FmtBinary<Self>where
Self: Binary,
fn fmt_binary(self) -> FmtBinary<Self>where
Self: Binary,
self
to use its Binary
implementation when Debug
-formatted.source§fn fmt_display(self) -> FmtDisplay<Self>where
Self: Display,
fn fmt_display(self) -> FmtDisplay<Self>where
Self: Display,
self
to use its Display
implementation when
Debug
-formatted.source§fn fmt_lower_exp(self) -> FmtLowerExp<Self>where
Self: LowerExp,
fn fmt_lower_exp(self) -> FmtLowerExp<Self>where
Self: LowerExp,
self
to use its LowerExp
implementation when
Debug
-formatted.source§fn fmt_lower_hex(self) -> FmtLowerHex<Self>where
Self: LowerHex,
fn fmt_lower_hex(self) -> FmtLowerHex<Self>where
Self: LowerHex,
self
to use its LowerHex
implementation when
Debug
-formatted.source§fn fmt_octal(self) -> FmtOctal<Self>where
Self: Octal,
fn fmt_octal(self) -> FmtOctal<Self>where
Self: Octal,
self
to use its Octal
implementation when Debug
-formatted.source§fn fmt_pointer(self) -> FmtPointer<Self>where
Self: Pointer,
fn fmt_pointer(self) -> FmtPointer<Self>where
Self: Pointer,
self
to use its Pointer
implementation when
Debug
-formatted.source§fn fmt_upper_exp(self) -> FmtUpperExp<Self>where
Self: UpperExp,
fn fmt_upper_exp(self) -> FmtUpperExp<Self>where
Self: UpperExp,
self
to use its UpperExp
implementation when
Debug
-formatted.source§fn fmt_upper_hex(self) -> FmtUpperHex<Self>where
Self: UpperHex,
fn fmt_upper_hex(self) -> FmtUpperHex<Self>where
Self: UpperHex,
self
to use its UpperHex
implementation when
Debug
-formatted.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> 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>
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>
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 moresource§impl<T> Pipe for Twhere
T: ?Sized,
impl<T> Pipe for Twhere
T: ?Sized,
source§fn pipe<R>(self, func: impl FnOnce(Self) -> R) -> Rwhere
Self: Sized,
fn pipe<R>(self, func: impl FnOnce(Self) -> R) -> Rwhere
Self: Sized,
source§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,
self
and passes that borrow into the pipe function. Read moresource§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,
self
and passes that borrow into the pipe function. Read moresource§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
source§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
source§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
self
, then passes self.as_ref()
into the pipe function.source§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
self
, then passes self.as_mut()
into the pipe
function.source§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
self
, then passes self.deref()
into the pipe function.source§impl<T> Pointable for T
impl<T> Pointable for T
source§impl<T> References<RawCodec> for T
impl<T> References<RawCodec> for T
source§impl<T> Tap for T
impl<T> Tap for T
source§fn tap_borrow<B>(self, func: impl FnOnce(&B)) -> Self
fn tap_borrow<B>(self, func: impl FnOnce(&B)) -> Self
Borrow<B>
of a value. Read moresource§fn tap_borrow_mut<B>(self, func: impl FnOnce(&mut B)) -> Self
fn tap_borrow_mut<B>(self, func: impl FnOnce(&mut B)) -> Self
BorrowMut<B>
of a value. Read moresource§fn tap_ref<R>(self, func: impl FnOnce(&R)) -> Self
fn tap_ref<R>(self, func: impl FnOnce(&R)) -> Self
AsRef<R>
view of a value. Read moresource§fn tap_ref_mut<R>(self, func: impl FnOnce(&mut R)) -> Self
fn tap_ref_mut<R>(self, func: impl FnOnce(&mut R)) -> Self
AsMut<R>
view of a value. Read moresource§fn tap_deref<T>(self, func: impl FnOnce(&T)) -> Self
fn tap_deref<T>(self, func: impl FnOnce(&T)) -> Self
Deref::Target
of a value. Read moresource§fn tap_deref_mut<T>(self, func: impl FnOnce(&mut T)) -> Self
fn tap_deref_mut<T>(self, func: impl FnOnce(&mut T)) -> Self
Deref::Target
of a value. Read moresource§fn tap_dbg(self, func: impl FnOnce(&Self)) -> Self
fn tap_dbg(self, func: impl FnOnce(&Self)) -> Self
.tap()
only in debug builds, and is erased in release builds.source§fn tap_mut_dbg(self, func: impl FnOnce(&mut Self)) -> Self
fn tap_mut_dbg(self, func: impl FnOnce(&mut Self)) -> Self
.tap_mut()
only in debug builds, and is erased in release
builds.source§fn tap_borrow_dbg<B>(self, func: impl FnOnce(&B)) -> Self
fn tap_borrow_dbg<B>(self, func: impl FnOnce(&B)) -> Self
.tap_borrow()
only in debug builds, and is erased in release
builds.source§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
.tap_borrow_mut()
only in debug builds, and is erased in release
builds.source§fn tap_ref_dbg<R>(self, func: impl FnOnce(&R)) -> Self
fn tap_ref_dbg<R>(self, func: impl FnOnce(&R)) -> Self
.tap_ref()
only in debug builds, and is erased in release
builds.source§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
.tap_ref_mut()
only in debug builds, and is erased in release
builds.source§fn tap_deref_dbg<T>(self, func: impl FnOnce(&T)) -> Self
fn tap_deref_dbg<T>(self, func: impl FnOnce(&T)) -> Self
.tap_deref()
only in debug builds, and is erased in release
builds.