Struct pallet_pool_system::tranches::Tranches

impl<Balance, Rate, Weight, TrancheCurrency, TrancheId, PoolId, MaxTranches> Tranches<Balance, Rate, Weight, TrancheCurrency, TrancheId, PoolId, MaxTranches>
where TrancheCurrency: Copy + TrancheCurrencyT<PoolId, TrancheId>, Balance: Zero + Copy + BaseArithmetic + FixedPointOperand + Unsigned + From<u64> + MultiplyRational, Weight: Copy + From<u128>, Rate: One + Copy + FixedPointNumber<Inner = Balance>, TrancheId: Clone + From<[u8; 16]> + PartialEq, PoolId: Copy + Encode, MaxTranches: Get<u32>,

pub fn from_input<StringLimit>( pool: PoolId, tranche_inputs: Vec<TrancheInput<Rate, StringLimit>>, now: Seconds ) -> Result<Self, DispatchError>
where StringLimit: Get<u32>,

pub fn tranche_currency( &self, id: TrancheLoc<TrancheId> ) -> Option<TrancheCurrency>

pub fn tranche_id(&self, id: TrancheLoc<TrancheId>) -> Option<TrancheId>

pub fn tranche_index(&self, id: &TrancheLoc<TrancheId>) -> Option<TrancheIndex>

pub fn get_mut_tranche( &mut self, id: TrancheLoc<TrancheId> ) -> Option<&mut Tranche<Balance, Rate, Weight, TrancheCurrency>>

pub fn get_tranche( &self, id: TrancheLoc<TrancheId> ) -> Option<&Tranche<Balance, Rate, Weight, TrancheCurrency>>

pub fn replace<StringLimit>( &mut self, at: TrancheIndex, tranche: TrancheInput<Rate, StringLimit>, now: Seconds ) -> DispatchResult
where StringLimit: Get<u32>,

pub fn validate_insert( &self, at: TrancheIndex, tranche: &Tranche<Balance, Rate, Weight, TrancheCurrency> ) -> DispatchResult

pub fn add<StringLimit>( &mut self, at: TrancheIndex, tranche: TrancheInput<Rate, StringLimit>, now: Seconds ) -> DispatchResult
where StringLimit: Get<u32>,

pub fn remove(&mut self, at: TrancheIndex) -> DispatchResult

Removing should only be possible if the Tranche at the given index has zero balance and is not the residual one.

pub fn ids_non_residual_top(&self) -> Vec<TrancheId>

pub fn of_pool(&self) -> PoolId

pub fn combine_non_residual_top<R, F>( &self, f: F ) -> Result<Vec<R>, DispatchError>
where F: FnMut(&Tranche<Balance, Rate, Weight, TrancheCurrency>) -> Result<R, DispatchError>,

pub fn combine_mut_non_residual_top<R, F>( &mut self, f: F ) -> Result<Vec<R>, DispatchError>
where F: FnMut(&mut Tranche<Balance, Rate, Weight, TrancheCurrency>) -> Result<R, DispatchError>,

pub fn combine_with_non_residual_top<R, I, W, F>( &self, with: I, f: F ) -> Result<Vec<R>, DispatchError>
where F: FnMut(&Tranche<Balance, Rate, Weight, TrancheCurrency>, W) -> Result<R, DispatchError>, I: IntoIterator<Item = W>,

pub fn combine_with_mut_non_residual_top<R, W, I, F>( &mut self, with: I, f: F ) -> Result<Vec<R>, DispatchError>
where F: FnMut(&mut Tranche<Balance, Rate, Weight, TrancheCurrency>, W) -> Result<R, DispatchError>, I: IntoIterator<Item = W>,

pub fn ids_residual_top(&self) -> Vec<TrancheId>

pub fn combine_residual_top<R, F>(&self, f: F) -> Result<Vec<R>, DispatchError>
where F: FnMut(&Tranche<Balance, Rate, Weight, TrancheCurrency>) -> Result<R, DispatchError>,

pub fn combine_mut_residual_top<R, F>( &mut self, f: F ) -> Result<Vec<R>, DispatchError>
where F: FnMut(&mut Tranche<Balance, Rate, Weight, TrancheCurrency>) -> Result<R, DispatchError>,

pub fn combine_with_residual_top<R, I, W, F>( &self, with: I, f: F ) -> Result<Vec<R>, DispatchError>
where F: FnMut(&Tranche<Balance, Rate, Weight, TrancheCurrency>, W) -> Result<R, DispatchError>, I: IntoIterator<Item = W>,

pub fn combine_with_mut_residual_top<R, W, I, F>( &mut self, with: I, f: F ) -> Result<Vec<R>, DispatchError>
where F: FnMut(&mut Tranche<Balance, Rate, Weight, TrancheCurrency>, W) -> Result<R, DispatchError>, I: IntoIterator<Item = W>,

pub fn calculate_prices<BalanceRatio, Tokens, AccountId>( &mut self, total_assets: Balance, now: Seconds ) -> Result<Vec<BalanceRatio>, DispatchError>
where BalanceRatio: FixedPointNumber<Inner = Balance>, Tokens: Inspect<AccountId, Balance = Balance>, TrancheCurrency: Into<<Tokens as Inspect<AccountId>>::AssetId>,

Returns the current prices of the tranches based on the current NAV and each tranche’s balance and total issuance at this exact moment. The correctness of the waterfall is ensured by starting at the top non-residual tranch.

pub fn num_tranches(&self) -> usize

pub fn into_tranches( self ) -> BoundedVec<Tranche<Balance, Rate, Weight, TrancheCurrency>, MaxTranches>

pub fn non_residual_tranches( &self ) -> Option<&[Tranche<Balance, Rate, Weight, TrancheCurrency>]>

pub fn non_residual_tranches_mut( &mut self ) -> Option<&mut [Tranche<Balance, Rate, Weight, TrancheCurrency>]>

pub fn residual_tranche( &self ) -> Option<&Tranche<Balance, Rate, Weight, TrancheCurrency>>

pub fn residual_tranche_mut( &mut self ) -> Option<&mut Tranche<Balance, Rate, Weight, TrancheCurrency>>

pub fn non_residual_top_slice( &self ) -> &RevSlice<Tranche<Balance, Rate, Weight, TrancheCurrency>>

pub fn non_residual_top_slice_mut( &mut self ) -> &mut RevSlice<Tranche<Balance, Rate, Weight, TrancheCurrency>>

pub fn residual_top_slice( &self ) -> &[Tranche<Balance, Rate, Weight, TrancheCurrency>]

pub fn residual_top_slice_mut( &mut self ) -> &mut [Tranche<Balance, Rate, Weight, TrancheCurrency>]

pub fn supplies(&self) -> Result<Vec<Balance>, DispatchError>

Returns each tranche’s total supply starting at the residual top.

pub fn acc_supply(&self) -> Result<Balance, DispatchError>

Returns the total supply over all tranches starting at the residual top.

pub fn min_risk_buffers(&self) -> Vec<Perquintill>

Returns each tranche’s min risk buffer starting at the residual top.

pub fn seniorities(&self) -> Vec<Seniority>

Returns each tranche’s seniority starting at the residual top.

pub fn rebalance_tranches( &mut self, now: Seconds, pool_total_reserve: Balance, pool_nav: Balance, tranche_ratios: &[Perquintill], executed_amounts: &[(Balance, Balance)] ) -> DispatchResult

Trait Implementations§

impl<Balance: Clone, Rate: Clone, Weight: Clone, TrancheCurrency: Clone, TrancheId: Clone, PoolId: Clone, MaxTranches> Clone for Tranches<Balance, Rate, Weight, TrancheCurrency, TrancheId, PoolId, MaxTranches>
where MaxTranches: Get<u32> + Clone,

fn clone( &self ) -> Tranches<Balance, Rate, Weight, TrancheCurrency, TrancheId, PoolId, MaxTranches>

Returns a copy of the value. Read more

1.0.0 · source§

fn clone_from(&mut self, source: &Self)

Performs copy-assignment from source. Read more

impl<Balance, Rate, Weight, TrancheCurrency, TrancheId, PoolId, MaxTranches> Debug for Tranches<Balance, Rate, Weight, TrancheCurrency, TrancheId, PoolId, MaxTranches>
where MaxTranches: Get<u32> + Debug, Balance: Debug, Rate: Debug, Weight: Debug, TrancheCurrency: Debug, TrancheId: Debug, PoolId: Debug,

fn fmt(&self, fmt: &mut Formatter<'_>) -> Result

Formats the value using the given formatter. Read more

impl<Balance, Rate, Weight, TrancheCurrency, TrancheId, PoolId, MaxTranches> Decode for Tranches<Balance, Rate, Weight, TrancheCurrency, TrancheId, PoolId, MaxTranches>
where MaxTranches: Get<u32>, BoundedVec<Tranche<Balance, Rate, Weight, TrancheCurrency>, MaxTranches>: Decode, BoundedVec<TrancheId, MaxTranches>: Decode, TrancheSalt<PoolId>: Decode,

fn decode<CodecInputEdqy: Input>( codec_input_edqy: &mut __CodecInputEdqy ) -> Result<Self, Error>

Attempt to deserialise the value from input.

fn decode_into( input: &mut I, dst: &mut MaybeUninit<Self> ) -> Result<DecodeFinished, Error>
where I: Input,

Attempt to deserialize the value from input into a pre-allocated piece of memory. Read more

fn skip(input: &mut I) -> Result<(), Error>
where I: Input,

Attempt to skip the encoded value from input. Read more

fn encoded_fixed_size() -> Option<usize>

Returns the fixed encoded size of the type. Read more

impl<Balance, Rate, Weight, TrancheCurrency, TrancheId, PoolId, MaxTranches> Encode for Tranches<Balance, Rate, Weight, TrancheCurrency, TrancheId, PoolId, MaxTranches>
where MaxTranches: Get<u32>, BoundedVec<Tranche<Balance, Rate, Weight, TrancheCurrency>, MaxTranches>: Encode, BoundedVec<TrancheId, MaxTranches>: Encode, TrancheSalt<PoolId>: Encode,

fn size_hint(&self) -> usize

If possible give a hint of expected size of the encoding. Read more

fn encode_to<CodecOutputEdqy: Output + ?Sized>( &self, codec_dest_edqy: &mut __CodecOutputEdqy )

Convert self to a slice and append it to the destination.

fn encode(&self) -> Vec<u8> ⓘ

Convert self to an owned vector.

fn using_encoded<R, F>(&self, f: F) -> R
where F: FnOnce(&[u8]) -> R,

Convert self to a slice and then invoke the given closure with it.

fn encoded_size(&self) -> usize

Calculates the encoded size. Read more

impl<Balance, Rate, Weight, TrancheCurrency, TrancheId, PoolId, MaxTranches> MaxEncodedLen for Tranches<Balance, Rate, Weight, TrancheCurrency, TrancheId, PoolId, MaxTranches>
where MaxTranches: Get<u32>, BoundedVec<Tranche<Balance, Rate, Weight, TrancheCurrency>, MaxTranches>: MaxEncodedLen, BoundedVec<TrancheId, MaxTranches>: MaxEncodedLen, TrancheSalt<PoolId>: MaxEncodedLen,

fn max_encoded_len() -> usize

Upper bound, in bytes, of the maximum encoded size of this item.

impl<Balance: PartialEq, Rate: PartialEq, Weight: PartialEq, TrancheCurrency: PartialEq, TrancheId: PartialEq, PoolId: PartialEq, MaxTranches> PartialEq for Tranches<Balance, Rate, Weight, TrancheCurrency, TrancheId, PoolId, MaxTranches>
where MaxTranches: Get<u32> + PartialEq,

fn eq( &self, other: &Tranches<Balance, Rate, Weight, TrancheCurrency, TrancheId, PoolId, MaxTranches> ) -> bool

This method tests for self and other values to be equal, and is used by ==.

1.0.0 · source§

fn ne(&self, other: &Rhs) -> bool

This method tests for !=. The default implementation is almost always sufficient, and should not be overridden without very good reason.

impl<Balance, Rate, Weight, TrancheCurrency, TrancheId, PoolId, MaxTranches> TypeInfo for Tranches<Balance, Rate, Weight, TrancheCurrency, TrancheId, PoolId, MaxTranches>
where MaxTranches: Get<u32> + TypeInfo + 'static, BoundedVec<Tranche<Balance, Rate, Weight, TrancheCurrency>, MaxTranches>: TypeInfo + 'static, BoundedVec<TrancheId, MaxTranches>: TypeInfo + 'static, TrancheSalt<PoolId>: TypeInfo + 'static, Balance: TypeInfo + 'static, Rate: TypeInfo + 'static, Weight: TypeInfo + 'static, TrancheCurrency: TypeInfo + 'static, TrancheId: TypeInfo + 'static, PoolId: TypeInfo + 'static,

type Identity = Tranches<Balance, Rate, Weight, TrancheCurrency, TrancheId, PoolId, MaxTranches>

The type identifying for which type info is provided. Read more

fn type_info() -> Type

Returns the static type identifier for Self.

impl<Balance, Rate, Weight, TrancheCurrency, TrancheId, PoolId, MaxTranches> EncodeLike for Tranches<Balance, Rate, Weight, TrancheCurrency, TrancheId, PoolId, MaxTranches>
where MaxTranches: Get<u32>, BoundedVec<Tranche<Balance, Rate, Weight, TrancheCurrency>, MaxTranches>: Encode, BoundedVec<TrancheId, MaxTranches>: Encode, TrancheSalt<PoolId>: Encode,

impl<Balance: Eq, Rate: Eq, Weight: Eq, TrancheCurrency: Eq, TrancheId: Eq, PoolId: Eq, MaxTranches> Eq for Tranches<Balance, Rate, Weight, TrancheCurrency, TrancheId, PoolId, MaxTranches>
where MaxTranches: Get<u32> + Eq,

impl<Balance, Rate, Weight, TrancheCurrency, TrancheId, PoolId, MaxTranches> StructuralPartialEq for Tranches<Balance, Rate, Weight, TrancheCurrency, TrancheId, PoolId, MaxTranches>
where MaxTranches: Get<u32>,

Auto Trait Implementations§

impl<Balance, Rate, Weight, TrancheCurrency, TrancheId, PoolId, MaxTranches> RefUnwindSafe for Tranches<Balance, Rate, Weight, TrancheCurrency, TrancheId, PoolId, MaxTranches>
where Balance: RefUnwindSafe, MaxTranches: RefUnwindSafe, PoolId: RefUnwindSafe, Rate: RefUnwindSafe, TrancheCurrency: RefUnwindSafe, TrancheId: RefUnwindSafe, Weight: RefUnwindSafe,

impl<Balance, Rate, Weight, TrancheCurrency, TrancheId, PoolId, MaxTranches> Send for Tranches<Balance, Rate, Weight, TrancheCurrency, TrancheId, PoolId, MaxTranches>
where Balance: Send, MaxTranches: Send, PoolId: Send, Rate: Send, TrancheCurrency: Send, TrancheId: Send, Weight: Send,

impl<Balance, Rate, Weight, TrancheCurrency, TrancheId, PoolId, MaxTranches> Sync for Tranches<Balance, Rate, Weight, TrancheCurrency, TrancheId, PoolId, MaxTranches>
where Balance: Sync, MaxTranches: Sync, PoolId: Sync, Rate: Sync, TrancheCurrency: Sync, TrancheId: Sync, Weight: Sync,

impl<Balance, Rate, Weight, TrancheCurrency, TrancheId, PoolId, MaxTranches> Unpin for Tranches<Balance, Rate, Weight, TrancheCurrency, TrancheId, PoolId, MaxTranches>
where Balance: Unpin, MaxTranches: Unpin, PoolId: Unpin, Rate: Unpin, TrancheCurrency: Unpin, TrancheId: Unpin, Weight: Unpin,

impl<Balance, Rate, Weight, TrancheCurrency, TrancheId, PoolId, MaxTranches> UnwindSafe for Tranches<Balance, Rate, Weight, TrancheCurrency, TrancheId, PoolId, MaxTranches>
where Balance: UnwindSafe, MaxTranches: UnwindSafe, PoolId: UnwindSafe, Rate: UnwindSafe, TrancheCurrency: UnwindSafe, TrancheId: UnwindSafe, Weight: UnwindSafe,

Blanket Implementations§

impl<T> Any for T
where T: 'static + ?Sized,

fn type_id(&self) -> TypeId

Gets the TypeId of self. Read more

impl<T> Borrow<T> for T
where T: ?Sized,

fn borrow(&self) -> &T

Immutably borrows from an owned value. Read more

impl<T> BorrowMut<T> for T
where T: ?Sized,

fn borrow_mut(&mut self) -> &mut T

Mutably borrows from an owned value. Read more

impl<T> CheckedConversion for T

fn checked_from<T>(t: T) -> Option<Self>
where Self: TryFrom<T>,

Convert from a value of T into an equivalent instance of Option<Self>. Read more

fn checked_into<T>(self) -> Option<T>
where Self: TryInto<T>,

Consume self to return Some equivalent value of Option<T>. Read more

impl<T> Conv for T

fn conv<T>(self) -> T
where Self: Into<T>,

Converts self into T using Into<T>. Read more

impl<T> DecodeAll for T
where T: Decode,

fn decode_all(input: &mut &[u8]) -> Result<T, Error>

Decode Self and consume all of the given input data. Read more

impl<T> DecodeLimit for T
where T: Decode,

fn decode_all_with_depth_limit( limit: u32, input: &mut &[u8] ) -> Result<T, Error>

Decode Self and consume all of the given input data. Read more

fn decode_with_depth_limit(limit: u32, input: &mut I) -> Result<T, Error>
where I: Input,

Decode Self with the given maximum recursion depth and advance input by the number of bytes consumed. Read more

fn encode_as(&self) -> Vec<u8> ⓘ

Convert Self into T, then encode T. Read more

impl<Q, K> Equivalent<K> for Q
where Q: Eq + ?Sized, K: Borrow<Q> + ?Sized,

fn equivalent(&self, key: &K) -> bool

Compare self to key and return true if they are equal.

impl<Q, K> Equivalent<K> for Q
where Q: Eq + ?Sized, K: Borrow<Q> + ?Sized,

fn equivalent(&self, key: &K) -> bool

Checks if this value is equivalent to the given key. Read more

impl<T> FmtForward for T

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,

Causes self to use its Display implementation when Debug-formatted.

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,

Causes self to use its LowerHex implementation when Debug-formatted.

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,

Causes self to use its Pointer implementation when Debug-formatted.

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,

Causes self to use its UpperHex implementation when Debug-formatted.

fn fmt_list(self) -> FmtList<Self>
where &'a Self: for<'a> IntoIterator,

Formats each item in a sequence. Read more

impl<T> From<T> for T

fn from(t: T) -> T

Returns the argument unchanged.

impl<T> Hashable for T
where T: Codec,

fn blake2_128(&self) -> [u8; 16]

fn blake2_256(&self) -> [u8; 32]

fn blake2_128_concat(&self) -> Vec<u8> ⓘ

fn twox_128(&self) -> [u8; 16]

fn twox_256(&self) -> [u8; 32]

fn twox_64_concat(&self) -> Vec<u8> ⓘ

fn identity(&self) -> Vec<u8> ⓘ

impl<T> Instrument for T

fn instrument(self, span: Span) -> Instrumented<Self>

Instruments this type with the provided [Span], returning an Instrumented wrapper. Read more

fn in_current_span(self) -> Instrumented<Self>

Instruments this type with the current Span, returning an Instrumented wrapper. Read more

impl<T, U> Into for T
where U: From<T>,

fn into(self) -> U

Calls U::from(self).

That is, this conversion is whatever the implementation of From<T> for U chooses to do.

impl<T, U> Into2 for T
where U: From2<T>,

fn into2(self) -> U

impl<T> IntoEither for T

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 more

fn into_either_with<F>(self, into_left: F) -> Either<Self, Self>
where F: FnOnce(&Self) -> bool,

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

fn from_ref(t: &T) -> &T

Cast reference.

fn into_ref(&self) -> &T

Cast reference.

fn from_mut(t: &mut T) -> &mut T

Cast mutable reference.

fn into_mut(&mut self) -> &mut T

Cast mutable reference.

impl<T, Outer> IsWrappedBy<Outer> for T
where Outer: AsRef<T> + AsMut<T> + From<T>, T: From<Outer>,

fn from_ref(outer: &Outer) -> &T

Get a reference to the inner from the outer.

fn from_mut(outer: &mut Outer) -> &mut T

Get a mutable reference to the inner from the outer.

impl<T> KeyedVec for T
where T: Codec,

fn to_keyed_vec(&self, prepend_key: &[u8]) -> Vec<u8> ⓘ

Return an encoding of Self prepended by given slice.

impl<T> Pipe for T
where T: ?Sized,

fn pipe<R>(self, func: impl FnOnce(Self) -> R) -> R
where 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) -> R
where 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) -> R
where 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
where Self: Borrow, B: 'a + ?Sized, R: 'a,

Borrows self, then passes self.borrow() into the pipe function. Read more

fn pipe_borrow_mut<'a, B, R>( &'a mut self, func: impl FnOnce(&'a mut B) -> R ) -> R
where Self: BorrowMut, B: 'a + ?Sized, R: 'a,

Mutably borrows self, then passes self.borrow_mut() into the pipe function. Read more

fn pipe_as_ref<'a, U, R>(&'a self, func: impl FnOnce(&'a U) -> R) -> R
where Self: AsRef, U: 'a + ?Sized, R: 'a,

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
where Self: AsMut, U: 'a + ?Sized, R: 'a,

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
where Self: Deref<Target = T>, T: 'a + ?Sized, R: 'a,

Borrows self, then passes self.deref() into the pipe function.

fn pipe_deref_mut<'a, T, R>( &'a mut self, func: impl FnOnce(&'a mut T) -> R ) -> R
where Self: DerefMut<Target = T> + Deref, T: 'a + ?Sized, R: 'a,

Mutably borrows self, then passes self.deref_mut() into the pipe function.

impl<T> Pointable for T

const ALIGN: usize = _

The alignment of pointer.

type Init = T

The type for initializers.

unsafe fn init(init: <T as Pointable>::Init) -> usize

Initializes a with the given initializer. Read more

unsafe fn deref<'a>(ptr: usize) -> &'a T

Dereferences the given pointer. Read more

unsafe fn deref_mut<'a>(ptr: usize) -> &'a mut T

Mutably dereferences the given pointer. Read more

unsafe fn drop(ptr: usize)

Drops the object pointed to by the given pointer. Read more

impl<T> Same for T

type Output = T

Should always be Self

impl<T> SaturatedConversion for T

fn saturated_from<T>(t: T) -> Self
where Self: UniqueSaturatedFrom<T>,

Convert from a value of T into an equivalent instance of Self. Read more

fn saturated_into<T>(self) -> T
where Self: UniqueSaturatedInto<T>,

Consume self to return an equivalent value of T. Read more

impl<T> Tap for T

fn tap(self, func: impl FnOnce(&Self)) -> Self

Immutable access to a value. Read more

fn tap_mut(self, func: impl FnOnce(&mut Self)) -> Self

Mutable access to a value. Read more

fn tap_borrow(self, func: impl FnOnce(&B)) -> Self
where Self: Borrow, B: ?Sized,

Immutable access to the Borrow of a value. Read more

fn tap_borrow_mut(self, func: impl FnOnce(&mut B)) -> Self
where Self: BorrowMut, B: ?Sized,

Mutable access to the BorrowMut of a value. Read more

fn tap_ref<R>(self, func: impl FnOnce(&R)) -> Self
where Self: AsRef<R>, R: ?Sized,

Immutable access to the AsRef<R> view of a value. Read more

fn tap_ref_mut<R>(self, func: impl FnOnce(&mut R)) -> Self
where Self: AsMut<R>, R: ?Sized,

Mutable access to the AsMut<R> view of a value. Read more

fn tap_deref<T>(self, func: impl FnOnce(&T)) -> Self
where Self: Deref<Target = T>, T: ?Sized,

Immutable access to the Deref::Target of a value. Read more

fn tap_deref_mut<T>(self, func: impl FnOnce(&mut T)) -> Self
where Self: DerefMut<Target = T> + Deref, T: ?Sized,

Mutable access to the Deref::Target of a value. Read more

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

Calls .tap_mut() only in debug builds, and is erased in release builds.

fn tap_borrow_dbg(self, func: impl FnOnce(&B)) -> Self
where Self: Borrow, B: ?Sized,

Calls .tap_borrow() only in debug builds, and is erased in release builds.

fn tap_borrow_mut_dbg(self, func: impl FnOnce(&mut B)) -> Self
where Self: BorrowMut, B: ?Sized,

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
where Self: AsRef<R>, R: ?Sized,

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
where Self: AsMut<R>, R: ?Sized,

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
where Self: Deref<Target = T>, T: ?Sized,

Calls .tap_deref() only in debug builds, and is erased in release builds.

fn tap_deref_mut_dbg<T>(self, func: impl FnOnce(&mut T)) -> Self
where Self: DerefMut<Target = T> + Deref, T: ?Sized,

Calls .tap_deref_mut() only in debug builds, and is erased in release builds.

impl<T> ToOwned for T
where T: Clone,

type Owned = T

The resulting type after obtaining ownership.

fn to_owned(&self) -> T

Creates owned data from borrowed data, usually by cloning. Read more

fn clone_into(&self, target: &mut T)

Uses borrowed data to replace owned data, usually by cloning. Read more

impl<T> TryConv for T

fn try_conv<T>(self) -> Result<T, Self::Error>
where Self: TryInto<T>,

Attempts to convert self into T using TryInto<T>. Read more

impl<T, U> TryFrom for T
where U: Into<T>,

type Error = Infallible

The type returned in the event of a conversion error.

fn try_from(value: U) -> Result<T, <T as TryFrom>::Error>

Performs the conversion.

impl<T, U> TryInto for T
where U: TryFrom<T>,

type Error = >::Error

The type returned in the event of a conversion error.

fn try_into(self) -> Result<U, >::Error>

Performs the conversion.

impl<T, U> TryInto2 for T
where U: TryFrom2<T>,

type Error = >::Error

fn try_into2(self) -> Result<U, >::Error>

impl<S, T> UncheckedInto<T> for S
where T: UncheckedFrom<S>,

fn unchecked_into(self) -> T

The counterpart to unchecked_from.

impl<T, S> UniqueSaturatedInto<T> for S
where T: Bounded, S: TryInto<T>,

fn unique_saturated_into(self) -> T

Consume self to return an equivalent value of T.

impl<V, T> VZip<V> for T
where V: MultiLane<T>,

fn vzip(self) -> V

impl<T> WithSubscriber for T

fn with_subscriber<S>(self, subscriber: S) -> WithDispatch<Self>
where S: Into<Dispatch>,

Attaches the provided Subscriber to this type, returning a [WithDispatch] wrapper. Read more

fn with_current_subscriber(self) -> WithDispatch<Self>

Attaches the current default Subscriber to this type, returning a [WithDispatch] wrapper. Read more

impl<T> AssetId for T
where T: FullCodec + Clone + Eq + PartialEq + Debug + TypeInfo + MaxEncodedLen,

impl<S> Codec for S
where S: Decode + Encode,

impl<T> EncodeLike<&&T> for T
where T: Encode,

impl<T> EncodeLike<&T> for T
where T: Encode,

impl<T> EncodeLike<&mut T> for T
where T: Encode,

impl<T> EncodeLike<Arc<T>> for T
where T: Encode,

impl<T> EncodeLike<Box<T>> for T
where T: Encode,

impl<'a, T> EncodeLike<Cow<'a, T>> for T
where T: ToOwned + Encode,

impl<T> EncodeLike<Rc<T>> for T
where T: Encode,

impl<S> FullCodec for S
where S: Decode + FullEncode,

impl<S> FullEncode for S
where S: Encode + EncodeLike,

impl<T> JsonSchemaMaybe for T

impl<T> MaybeDebug for T
where T: Debug,

impl<T> MaybeRefUnwindSafe for T
where T: RefUnwindSafe,

impl<T> Member for T
where T: Send + Sync + Debug + Eq + PartialEq + Clone + 'static,

impl<T> Parameter for T
where T: Codec + EncodeLike + Clone + Eq + Debug + TypeInfo,