Struct sp_weights::Weight

pub struct Weight { /* private fields */ }

Implementations

impl Weight

pub const fn set_ref_time(self, c: u64) -> Self

Set the reference time part of the weight.

pub const fn set_proof_size(self, c: u64) -> Self

Set the storage size part of the weight.

pub const fn ref_time(&self) -> u64

Return the reference time part of the weight.

Examples found in repository

src/weight_meter.rs (line 69)

	pub fn consumed_ratio(&self) -> Perbill {
		let time = Perbill::from_rational(self.consumed.ref_time(), self.limit.ref_time());
		let pov = Perbill::from_rational(self.consumed.proof_size(), self.limit.proof_size());
		time.max(pov)
	}

src/lib.rs (line 170)

	fn weight_to_fee(weight: &Weight) -> Self::Balance {
		Self::polynomial()
			.iter()
			.fold(Self::Balance::saturated_from(0u32), |mut acc, args| {
				let w = Self::Balance::saturated_from(weight.ref_time())
					.saturating_pow(args.degree.into());

				// The sum could get negative. Therefore we only sum with the accumulator.
				// The Perbill Mul implementation is non overflowing.
				let frac = args.coeff_frac * w;
				let integer = args.coeff_integer.saturating_mul(w);

				if args.negative {
					acc = acc.saturating_sub(frac);
					acc = acc.saturating_sub(integer);
				} else {
					acc = acc.saturating_add(frac);
					acc = acc.saturating_add(integer);
				}

				acc
			})
	}
}

/// Implementor of `WeightToFee` that maps one unit of weight to one unit of fee.
pub struct IdentityFee<T>(sp_std::marker::PhantomData<T>);

impl<T> WeightToFee for IdentityFee<T>
where
	T: BaseArithmetic + From<u32> + Copy + Unsigned,
{
	type Balance = T;

	fn weight_to_fee(weight: &Weight) -> Self::Balance {
		Self::Balance::saturated_from(weight.ref_time())
	}
}

/// Implementor of [`WeightToFee`] that uses a constant multiplier.
/// # Example
///
/// ```
/// # use sp_core::ConstU128;
/// # use sp_weights::ConstantMultiplier;
/// // Results in a multiplier of 10 for each unit of weight (or length)
/// type LengthToFee = ConstantMultiplier::<u128, ConstU128<10u128>>;
/// ```
pub struct ConstantMultiplier<T, M>(sp_std::marker::PhantomData<(T, M)>);

impl<T, M> WeightToFee for ConstantMultiplier<T, M>
where
	T: BaseArithmetic + From<u32> + Copy + Unsigned,
	M: Get<T>,
{
	type Balance = T;

	fn weight_to_fee(weight: &Weight) -> Self::Balance {
		Self::Balance::saturated_from(weight.ref_time()).saturating_mul(M::get())
	}

pub const fn proof_size(&self) -> u64

Return the storage size part of the weight.

Examples found in repository

src/weight_meter.rs (line 70)

	pub fn consumed_ratio(&self) -> Perbill {
		let time = Perbill::from_rational(self.consumed.ref_time(), self.limit.ref_time());
		let pov = Perbill::from_rational(self.consumed.proof_size(), self.limit.proof_size());
		time.max(pov)
	}

pub fn ref_time_mut(&mut self) -> &mut u64

Return a mutable reference to the reference time part of the weight.

pub fn proof_size_mut(&mut self) -> &mut u64

Return a mutable reference to the storage size part of the weight.

pub const MAX: Self = _

pub fn min(&self, other: Self) -> Self

Get the conservative min of self and other weight.

pub fn max(&self, other: Self) -> Self

Get the aggressive max of self and other weight.

pub fn try_add(&self, other: &Self, limit: &Self) -> Option<Self>

Try to add some other weight while upholding the limit.

pub const fn from_ref_time(ref_time: u64) -> Self

Construct Weight with reference time weight and 0 storage size weight.

Examples found in repository

src/weight_v2.rs (line 40)

	fn from(old: OldWeight) -> Self {
		Weight::from_ref_time(old.0)
	}

src/lib.rs (line 92)

	pub fn reads(self, r: u64) -> Weight {
		Weight::from_ref_time(self.read.saturating_mul(r))
	}

	pub fn writes(self, w: u64) -> Weight {
		Weight::from_ref_time(self.write.saturating_mul(w))
	}

	pub fn reads_writes(self, r: u64, w: u64) -> Weight {
		let read_weight = self.read.saturating_mul(r);
		let write_weight = self.write.saturating_mul(w);
		Weight::from_ref_time(read_weight.saturating_add(write_weight))
	}

pub const fn from_proof_size(proof_size: u64) -> Self

Construct Weight with storage size weight and 0 reference time weight.

pub const fn from_parts(ref_time: u64, proof_size: u64) -> Self

Construct Weight from weight parts, namely reference time and proof size weights.

pub const fn saturating_add(self, rhs: Self) -> Self

Saturating Weight addition. Computes self + rhs, saturating at the numeric bounds of all fields instead of overflowing.

Examples found in repository

src/weight_v2.rs (line 167)

	pub fn saturating_accrue(&mut self, amount: Self) {
		*self = self.saturating_add(amount);
	}

pub const fn saturating_sub(self, rhs: Self) -> Self

Saturating Weight subtraction. Computes self - rhs, saturating at the numeric bounds of all fields instead of overflowing.

Examples found in repository

src/weight_meter.rs (line 62)

	pub fn remaining(&self) -> Weight {
		self.limit.saturating_sub(self.consumed)
	}

pub const fn saturating_mul(self, scalar: u64) -> Self

Saturating Weight scalar multiplication. Computes self.field * scalar for all fields, saturating at the numeric bounds of all fields instead of overflowing.

pub const fn saturating_div(self, scalar: u64) -> Self

Saturating Weight scalar division. Computes self.field / scalar for all fields, saturating at the numeric bounds of all fields instead of overflowing.

pub const fn saturating_pow(self, exp: u32) -> Self

Saturating Weight scalar exponentiation. Computes self.field.pow(exp) for all fields, saturating at the numeric bounds of all fields instead of overflowing.

pub fn saturating_accrue(&mut self, amount: Self)

Increment Weight by amount via saturating addition.

Examples found in repository

src/weight_meter.rs (line 76)

	pub fn defensive_saturating_accrue(&mut self, w: Weight) {
		self.consumed.saturating_accrue(w);
		debug_assert!(self.consumed.all_lte(self.limit), "Weight counter overflow");
	}

pub const fn checked_add(&self, rhs: &Self) -> Option<Self>

Checked Weight addition. Computes self + rhs, returning None if overflow occurred.

Examples found in repository

src/weight_v2.rs (line 97)

	pub fn try_add(&self, other: &Self, limit: &Self) -> Option<Self> {
		let total = self.checked_add(other)?;
		if total.any_gt(*limit) {
			None
		} else {
			Some(total)
		}
	}

	/// Construct [`Weight`] with reference time weight and 0 storage size weight.
	pub const fn from_ref_time(ref_time: u64) -> Self {
		Self { ref_time, proof_size: 0 }
	}

	/// Construct [`Weight`] with storage size weight and 0 reference time weight.
	pub const fn from_proof_size(proof_size: u64) -> Self {
		Self { ref_time: 0, proof_size }
	}

	/// Construct [`Weight`] from weight parts, namely reference time and proof size weights.
	pub const fn from_parts(ref_time: u64, proof_size: u64) -> Self {
		Self { ref_time, proof_size }
	}

	/// Saturating [`Weight`] addition. Computes `self + rhs`, saturating at the numeric bounds of
	/// all fields instead of overflowing.
	pub const fn saturating_add(self, rhs: Self) -> Self {
		Self {
			ref_time: self.ref_time.saturating_add(rhs.ref_time),
			proof_size: self.proof_size.saturating_add(rhs.proof_size),
		}
	}

	/// Saturating [`Weight`] subtraction. Computes `self - rhs`, saturating at the numeric bounds
	/// of all fields instead of overflowing.
	pub const fn saturating_sub(self, rhs: Self) -> Self {
		Self {
			ref_time: self.ref_time.saturating_sub(rhs.ref_time),
			proof_size: self.proof_size.saturating_sub(rhs.proof_size),
		}
	}

	/// Saturating [`Weight`] scalar multiplication. Computes `self.field * scalar` for all fields,
	/// saturating at the numeric bounds of all fields instead of overflowing.
	pub const fn saturating_mul(self, scalar: u64) -> Self {
		Self {
			ref_time: self.ref_time.saturating_mul(scalar),
			proof_size: self.proof_size.saturating_mul(scalar),
		}
	}

	/// Saturating [`Weight`] scalar division. Computes `self.field / scalar` for all fields,
	/// saturating at the numeric bounds of all fields instead of overflowing.
	pub const fn saturating_div(self, scalar: u64) -> Self {
		Self {
			ref_time: self.ref_time.saturating_div(scalar),
			proof_size: self.proof_size.saturating_div(scalar),
		}
	}

	/// Saturating [`Weight`] scalar exponentiation. Computes `self.field.pow(exp)` for all fields,
	/// saturating at the numeric bounds of all fields instead of overflowing.
	pub const fn saturating_pow(self, exp: u32) -> Self {
		Self {
			ref_time: self.ref_time.saturating_pow(exp),
			proof_size: self.proof_size.saturating_pow(exp),
		}
	}

	/// Increment [`Weight`] by `amount` via saturating addition.
	pub fn saturating_accrue(&mut self, amount: Self) {
		*self = self.saturating_add(amount);
	}

	/// Checked [`Weight`] addition. Computes `self + rhs`, returning `None` if overflow occurred.
	pub const fn checked_add(&self, rhs: &Self) -> Option<Self> {
		let ref_time = match self.ref_time.checked_add(rhs.ref_time) {
			Some(t) => t,
			None => return None,
		};
		let proof_size = match self.proof_size.checked_add(rhs.proof_size) {
			Some(s) => s,
			None => return None,
		};
		Some(Self { ref_time, proof_size })
	}

	/// Checked [`Weight`] subtraction. Computes `self - rhs`, returning `None` if overflow
	/// occurred.
	pub const fn checked_sub(&self, rhs: &Self) -> Option<Self> {
		let ref_time = match self.ref_time.checked_sub(rhs.ref_time) {
			Some(t) => t,
			None => return None,
		};
		let proof_size = match self.proof_size.checked_sub(rhs.proof_size) {
			Some(s) => s,
			None => return None,
		};
		Some(Self { ref_time, proof_size })
	}

	/// Checked [`Weight`] scalar multiplication. Computes `self.field * scalar` for each field,
	/// returning `None` if overflow occurred.
	pub const fn checked_mul(self, scalar: u64) -> Option<Self> {
		let ref_time = match self.ref_time.checked_mul(scalar) {
			Some(t) => t,
			None => return None,
		};
		let proof_size = match self.proof_size.checked_mul(scalar) {
			Some(s) => s,
			None => return None,
		};
		Some(Self { ref_time, proof_size })
	}

	/// Checked [`Weight`] scalar division. Computes `self.field / scalar` for each field, returning
	/// `None` if overflow occurred.
	pub const fn checked_div(self, scalar: u64) -> Option<Self> {
		let ref_time = match self.ref_time.checked_div(scalar) {
			Some(t) => t,
			None => return None,
		};
		let proof_size = match self.proof_size.checked_div(scalar) {
			Some(s) => s,
			None => return None,
		};
		Some(Self { ref_time, proof_size })
	}

	/// Return a [`Weight`] where all fields are zero.
	pub const fn zero() -> Self {
		Self { ref_time: 0, proof_size: 0 }
	}

	/// Constant version of Add with u64.
	///
	/// Is only overflow safe when evaluated at compile-time.
	pub const fn add(self, scalar: u64) -> Self {
		Self { ref_time: self.ref_time + scalar, proof_size: self.proof_size + scalar }
	}

	/// Constant version of Sub with u64.
	///
	/// Is only overflow safe when evaluated at compile-time.
	pub const fn sub(self, scalar: u64) -> Self {
		Self { ref_time: self.ref_time - scalar, proof_size: self.proof_size - scalar }
	}

	/// Constant version of Div with u64.
	///
	/// Is only overflow safe when evaluated at compile-time.
	pub const fn div(self, scalar: u64) -> Self {
		Self { ref_time: self.ref_time / scalar, proof_size: self.proof_size / scalar }
	}

	/// Constant version of Mul with u64.
	///
	/// Is only overflow safe when evaluated at compile-time.
	pub const fn mul(self, scalar: u64) -> Self {
		Self { ref_time: self.ref_time * scalar, proof_size: self.proof_size * scalar }
	}

	/// Returns true if any of `self`'s constituent weights is strictly greater than that of the
	/// `other`'s, otherwise returns false.
	pub const fn any_gt(self, other: Self) -> bool {
		self.ref_time > other.ref_time || self.proof_size > other.proof_size
	}

	/// Returns true if all of `self`'s constituent weights is strictly greater than that of the
	/// `other`'s, otherwise returns false.
	pub const fn all_gt(self, other: Self) -> bool {
		self.ref_time > other.ref_time && self.proof_size > other.proof_size
	}

	/// Returns true if any of `self`'s constituent weights is strictly less than that of the
	/// `other`'s, otherwise returns false.
	pub const fn any_lt(self, other: Self) -> bool {
		self.ref_time < other.ref_time || self.proof_size < other.proof_size
	}

	/// Returns true if all of `self`'s constituent weights is strictly less than that of the
	/// `other`'s, otherwise returns false.
	pub const fn all_lt(self, other: Self) -> bool {
		self.ref_time < other.ref_time && self.proof_size < other.proof_size
	}

	/// Returns true if any of `self`'s constituent weights is greater than or equal to that of the
	/// `other`'s, otherwise returns false.
	pub const fn any_gte(self, other: Self) -> bool {
		self.ref_time >= other.ref_time || self.proof_size >= other.proof_size
	}

	/// Returns true if all of `self`'s constituent weights is greater than or equal to that of the
	/// `other`'s, otherwise returns false.
	pub const fn all_gte(self, other: Self) -> bool {
		self.ref_time >= other.ref_time && self.proof_size >= other.proof_size
	}

	/// Returns true if any of `self`'s constituent weights is less than or equal to that of the
	/// `other`'s, otherwise returns false.
	pub const fn any_lte(self, other: Self) -> bool {
		self.ref_time <= other.ref_time || self.proof_size <= other.proof_size
	}

	/// Returns true if all of `self`'s constituent weights is less than or equal to that of the
	/// `other`'s, otherwise returns false.
	pub const fn all_lte(self, other: Self) -> bool {
		self.ref_time <= other.ref_time && self.proof_size <= other.proof_size
	}

	/// Returns true if any of `self`'s constituent weights is equal to that of the `other`'s,
	/// otherwise returns false.
	pub const fn any_eq(self, other: Self) -> bool {
		self.ref_time == other.ref_time || self.proof_size == other.proof_size
	}

	// NOTE: `all_eq` does not exist, as it's simply the `eq` method from the `PartialEq` trait.
}

impl Zero for Weight {
	fn zero() -> Self {
		Self::zero()
	}

	fn is_zero(&self) -> bool {
		self == &Self::zero()
	}
}

impl Add for Weight {
	type Output = Self;
	fn add(self, rhs: Self) -> Self {
		Self {
			ref_time: self.ref_time + rhs.ref_time,
			proof_size: self.proof_size + rhs.proof_size,
		}
	}
}

impl Sub for Weight {
	type Output = Self;
	fn sub(self, rhs: Self) -> Self {
		Self {
			ref_time: self.ref_time - rhs.ref_time,
			proof_size: self.proof_size - rhs.proof_size,
		}
	}
}

impl<T> Mul<T> for Weight
where
	T: Mul<u64, Output = u64> + Copy,
{
	type Output = Self;
	fn mul(self, b: T) -> Self {
		Self { ref_time: b * self.ref_time, proof_size: b * self.proof_size }
	}
}

macro_rules! weight_mul_per_impl {
	($($t:ty),* $(,)?) => {
		$(
			impl Mul<Weight> for $t {
				type Output = Weight;
				fn mul(self, b: Weight) -> Weight {
					Weight {
						ref_time: self * b.ref_time,
						proof_size: self * b.proof_size,
					}
				}
			}
		)*
	}
}
weight_mul_per_impl!(
	sp_arithmetic::Percent,
	sp_arithmetic::PerU16,
	sp_arithmetic::Permill,
	sp_arithmetic::Perbill,
	sp_arithmetic::Perquintill,
);

macro_rules! weight_mul_primitive_impl {
	($($t:ty),* $(,)?) => {
		$(
			impl Mul<Weight> for $t {
				type Output = Weight;
				fn mul(self, b: Weight) -> Weight {
					Weight {
						ref_time: u64::from(self) * b.ref_time,
						proof_size: u64::from(self) * b.proof_size,
					}
				}
			}
		)*
	}
}
weight_mul_primitive_impl!(u8, u16, u32, u64);

impl<T> Div<T> for Weight
where
	u64: Div<T, Output = u64>,
	T: Copy,
{
	type Output = Self;
	fn div(self, b: T) -> Self {
		Self { ref_time: self.ref_time / b, proof_size: self.proof_size / b }
	}
}

impl CheckedAdd for Weight {
	fn checked_add(&self, rhs: &Self) -> Option<Self> {
		self.checked_add(rhs)
	}

src/weight_meter.rs (line 82)

	pub fn check_accrue(&mut self, w: Weight) -> bool {
		self.consumed.checked_add(&w).map_or(false, |test| {
			if test.any_gt(self.limit) {
				false
			} else {
				self.consumed = test;
				true
			}
		})
	}

	/// Check if the given weight can be consumed.
	pub fn can_accrue(&self, w: Weight) -> bool {
		self.consumed.checked_add(&w).map_or(false, |t| t.all_lte(self.limit))
	}

pub const fn checked_sub(&self, rhs: &Self) -> Option<Self>

Checked Weight subtraction. Computes self - rhs, returning None if overflow occurred.

Examples found in repository

src/weight_v2.rs (line 414)

	fn checked_sub(&self, rhs: &Self) -> Option<Self> {
		self.checked_sub(rhs)
	}

pub const fn checked_mul(self, scalar: u64) -> Option<Self>

Checked Weight scalar multiplication. Computes self.field * scalar for each field, returning None if overflow occurred.

pub const fn checked_div(self, scalar: u64) -> Option<Self>

Checked Weight scalar division. Computes self.field / scalar for each field, returning None if overflow occurred.

pub const fn zero() -> Self

Return a Weight where all fields are zero.

Examples found in repository

src/weight_v2.rs (line 317)

	fn zero() -> Self {
		Self::zero()
	}

	fn is_zero(&self) -> bool {
		self == &Self::zero()
	}

src/weight_meter.rs (line 52)

	pub fn from_limit(limit: Weight) -> Self {
		Self { consumed: Weight::zero(), limit }
	}

pub const fn add(self, scalar: u64) -> Self

Constant version of Add with u64.

Is only overflow safe when evaluated at compile-time.

pub const fn sub(self, scalar: u64) -> Self

Constant version of Sub with u64.

Is only overflow safe when evaluated at compile-time.

pub const fn div(self, scalar: u64) -> Self

Constant version of Div with u64.

Is only overflow safe when evaluated at compile-time.

pub const fn mul(self, scalar: u64) -> Self

Constant version of Mul with u64.

Is only overflow safe when evaluated at compile-time.

pub const fn any_gt(self, other: Self) -> bool

Returns true if any of self’s constituent weights is strictly greater than that of the other’s, otherwise returns false.

Examples found in repository

src/weight_v2.rs (line 98)

	pub fn try_add(&self, other: &Self, limit: &Self) -> Option<Self> {
		let total = self.checked_add(other)?;
		if total.any_gt(*limit) {
			None
		} else {
			Some(total)
		}
	}

src/weight_meter.rs (line 83)

	pub fn check_accrue(&mut self, w: Weight) -> bool {
		self.consumed.checked_add(&w).map_or(false, |test| {
			if test.any_gt(self.limit) {
				false
			} else {
				self.consumed = test;
				true
			}
		})
	}

pub const fn all_gt(self, other: Self) -> bool

Returns true if all of self’s constituent weights is strictly greater than that of the other’s, otherwise returns false.

pub const fn any_lt(self, other: Self) -> bool

Returns true if any of self’s constituent weights is strictly less than that of the other’s, otherwise returns false.

pub const fn all_lt(self, other: Self) -> bool

Returns true if all of self’s constituent weights is strictly less than that of the other’s, otherwise returns false.

pub const fn any_gte(self, other: Self) -> bool

Returns true if any of self’s constituent weights is greater than or equal to that of the other’s, otherwise returns false.

pub const fn all_gte(self, other: Self) -> bool

Returns true if all of self’s constituent weights is greater than or equal to that of the other’s, otherwise returns false.

pub const fn any_lte(self, other: Self) -> bool

Returns true if any of self’s constituent weights is less than or equal to that of the other’s, otherwise returns false.

pub const fn all_lte(self, other: Self) -> bool

Returns true if all of self’s constituent weights is less than or equal to that of the other’s, otherwise returns false.

Examples found in repository

src/weight_meter.rs (line 77)

	pub fn defensive_saturating_accrue(&mut self, w: Weight) {
		self.consumed.saturating_accrue(w);
		debug_assert!(self.consumed.all_lte(self.limit), "Weight counter overflow");
	}

	/// Consume the given weight after checking that it can be consumed. Otherwise do nothing.
	pub fn check_accrue(&mut self, w: Weight) -> bool {
		self.consumed.checked_add(&w).map_or(false, |test| {
			if test.any_gt(self.limit) {
				false
			} else {
				self.consumed = test;
				true
			}
		})
	}

	/// Check if the given weight can be consumed.
	pub fn can_accrue(&self, w: Weight) -> bool {
		self.consumed.checked_add(&w).map_or(false, |t| t.all_lte(self.limit))
	}

pub const fn any_eq(self, other: Self) -> bool

Returns true if any of self’s constituent weights is equal to that of the other’s, otherwise returns false.

Trait Implementations

impl Add<Weight> for Weight

type Output = Weight

The resulting type after applying the + operator.

fn add(self, rhs: Self) -> Self

Performs the + operation.

impl AddAssign<Weight> for Weight

fn add_assign(&mut self, other: Self)

Performs the += operation.

impl Bounded for Weight

fn min_value() -> Self

Returns the smallest finite number this type can represent

fn max_value() -> Self

Returns the largest finite number this type can represent

impl CheckedAdd for Weight

fn checked_add(&self, rhs: &Self) -> Option<Self>

Adds two numbers, checking for overflow. If overflow happens, None is returned.

impl CheckedSub for Weight

fn checked_sub(&self, rhs: &Self) -> Option<Self>

Subtracts two numbers, checking for underflow. If underflow happens, None is returned.

impl Clone for Weight

fn clone(&self) -> Weight

Returns a copy of the value.

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

Performs copy-assignment from source.

impl Debug for Weight

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

Formats the value using the given formatter.

impl Decode for Weight

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

Attempt to deserialise the value from input.

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

Attempt to skip the encoded value from input.

fn encoded_fixed_size() -> Option<usize>

Returns the fixed encoded size of the type.

impl Default for Weight

fn default() -> Weight

Returns the “default value” for a type.

impl<'de> Deserialize<'de> for Weight

fn deserialize<__D>(__deserializer: __D) -> Result<Self, __D::Error>where
    __D: Deserializer<'de>,

Deserialize this value from the given Serde deserializer.

impl Display for Weight

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

Formats the value using the given formatter.

impl<T> Div<T> for Weightwhere
    u64: Div<T, Output = u64>,
    T: Copy,

type Output = Weight

The resulting type after applying the / operator.

fn div(self, b: T) -> Self

Performs the / operation.

impl Encode for Weight

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

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

fn size_hint(&self) -> usize

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

fn encode(&self) -> Vec<u8, Global>

Convert self to an owned vector.

fn using_encoded<R, F>(&self, f: F) -> Rwhere
    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.

impl From<OldWeight> for Weight

fn from(old: OldWeight) -> Self

Converts to this type from the input type.

impl MaxEncodedLen for Weight

fn max_encoded_len() -> usize

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

impl<T> Mul<T> for Weightwhere
    T: Mul<u64, Output = u64> + Copy,

type Output = Weight

The resulting type after applying the * operator.

fn mul(self, b: T) -> Self

Performs the * operation.

impl Mul<Weight> for PerU16

type Output = Weight

The resulting type after applying the * operator.

fn mul(self, b: Weight) -> Weight

Performs the * operation.

impl Mul<Weight> for Perbill

type Output = Weight

The resulting type after applying the * operator.

fn mul(self, b: Weight) -> Weight

Performs the * operation.

impl Mul<Weight> for Percent

type Output = Weight

The resulting type after applying the * operator.

fn mul(self, b: Weight) -> Weight

Performs the * operation.

impl Mul<Weight> for Permill

type Output = Weight

The resulting type after applying the * operator.

fn mul(self, b: Weight) -> Weight

Performs the * operation.

impl Mul<Weight> for Perquintill

type Output = Weight

The resulting type after applying the * operator.

fn mul(self, b: Weight) -> Weight

Performs the * operation.

impl Mul<Weight> for u16

type Output = Weight

The resulting type after applying the * operator.

fn mul(self, b: Weight) -> Weight

Performs the * operation.

impl Mul<Weight> for u32

type Output = Weight

The resulting type after applying the * operator.

fn mul(self, b: Weight) -> Weight

Performs the * operation.

impl Mul<Weight> for u64

type Output = Weight

The resulting type after applying the * operator.

fn mul(self, b: Weight) -> Weight

Performs the * operation.

impl Mul<Weight> for u8

type Output = Weight

The resulting type after applying the * operator.

fn mul(self, b: Weight) -> Weight

Performs the * operation.

impl PartialEq<Weight> for Weight

fn eq(&self, other: &Weight) -> bool

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

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 Serialize for Weight

fn serialize<__S>(&self, __serializer: __S) -> Result<__S::Ok, __S::Error>where
    __S: Serializer,

Serialize this value into the given Serde serializer.

impl Sub<Weight> for Weight

type Output = Weight

The resulting type after applying the - operator.

fn sub(self, rhs: Self) -> Self

Performs the - operation.

impl SubAssign<Weight> for Weight

fn sub_assign(&mut self, other: Self)

Performs the -= operation.

impl TypeInfo for Weight

type Identity = Weight

The type identifying for which type info is provided.

fn type_info() -> Type

Returns the static type identifier for Self.

impl Zero for Weight

fn zero() -> Self

Returns the additive identity element of Self, 0.

fn is_zero(&self) -> bool

Returns true if self is equal to the additive identity.

fn set_zero(&mut self)

Sets self to the additive identity element of Self, 0.

impl Copy for Weight

impl EncodeLike<Weight> for Weight

impl Eq for Weight

impl StructuralEq for Weight

impl StructuralPartialEq for Weight