Struct frame_system::limits::WeightsPerClass

pub struct WeightsPerClass {
    pub base_extrinsic: Weight,
    pub max_extrinsic: Option<Weight>,
    pub max_total: Option<Weight>,
    pub reserved: Option<Weight>,
}

DispatchClass-specific weight configuration.

Fields

base_extrinsic: Weight

Base weight of single extrinsic of given class.

max_extrinsic: Option<Weight>

Maximal weight of single extrinsic. Should NOT include base_extrinsic cost.

None indicates that this class of extrinsics doesn’t have a limit.

max_total: Option<Weight>

Block maximal total weight for all extrinsics of given class.

None indicates that weight sum of this class of extrinsics is not restricted. Use this value carefully, since it might produce heavily oversized blocks.

In the worst case, the total weight consumed by the class is going to be: MAX(max_total) + MAX(reserved).

reserved: Option<Weight>

Block reserved allowance for all extrinsics of a particular class.

Setting to None indicates that extrinsics of that class are allowed to go over total block weight (but at most max_total for that class). Setting to Some(x) guarantees that at least x weight of particular class is processed in every block.

Trait Implementations

impl Clone for WeightsPerClass

fn clone(&self) -> WeightsPerClass

Returns a copy of the value.

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

Performs copy-assignment from source.

impl Debug for WeightsPerClass

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

Formats the value using the given formatter.

impl Decode for WeightsPerClass

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

Attempt to deserialise the value from input.

fn decode_into<I>( 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.

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 Encode for WeightsPerClass

fn size_hint(&self) -> usize

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

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.

impl TypeInfo for WeightsPerClass

type Identity = WeightsPerClass

The type identifying for which type info is provided.

fn type_info() -> Type

Returns the static type identifier for Self.

impl EncodeLike for WeightsPerClass