Struct Stepper

pub struct Stepper<T: Config<I>, I: 'static> {
    pub threshold: T::Pulse,
    pub per_count: T::Pulse,
}

Configuration structure for discrete accumulation operations.

This struct defines the operational parameters for discrete accumulation, working in conjunction with the Accumulator to implement threshold-based progression systems. It encapsulates the rules that govern how steps are applied and when accumulated values should be incremented.

Fields

• threshold - The step count required to increment the accumulated value
• per_count - The number of steps added per accumulation operation

Fields

threshold: T::Pulse

The step count threshold required to increment the accumulated value.

When the accumulator’s step count reaches or exceeds this threshold, the accumulated value is incremented and the step count is adjusted. This defines the “cost” of each value increment in terms of steps.

per_count: T::Pulse

The number of steps added per accumulation operation.

This defines how much progress is made towards the threshold with each discrete accumulation operation. Multiple operations may be required to reach the threshold and trigger a value increment.

Implementations

impl<T: Config<I>, I: 'static> Stepper<T, I>

pub fn new(threshold: T::Pulse, per_count: T::Pulse) -> Option<Self>

Creates and returns a new stepper instance with the specified threshold and per-count values.

Condition

Returns None if per_count >= threshold, as this would cause immediate value increments without meaningful step accumulation.

Trait Implementations

impl<T, I> Clone for Stepper<T, I>

where T: Config<I>, T::Pulse: Clone,

fn clone(&self) -> Self

Returns a duplicate of the value.

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

Performs copy-assignment from source.

impl<T, I> Debug for Stepper<T, I>

where T: Config<I>, T::Pulse: Debug,

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

Formats the value using the given formatter.

impl<T: Config<I>, I: 'static> Decode for Stepper<T, I>

where T::Pulse: Decode,

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<T: Config<I>, I: 'static> Default for Stepper<T, I>

This is only utilized for mock testing/instances. Elsewhere Stepper::new should be utilized

A Mock Default implemetation for the Stepper struct.

This is confidently not utilized for runtime, and only as a marker for StorageValue’s ValueQuery default trait bound satisfaction since genesis config already requires this struct for PulseFactor.

fn default() -> Self

Returns the “default value” for a type.

impl<'de, T: Config<I>, I: 'static> Deserialize<'de> for Stepper<T, I>

where T::Pulse: Deserialize<'de>,

fn deserialize<__D>(__deserializer: __D) -> Result<Self, __D::Error>

where __D: Deserializer<'de>,

Deserialize this value from the given Serde deserializer.

impl<T: Config<I>, I: 'static> Encode for Stepper<T, I>

where T::Pulse: Encode,

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<T: Config<I>, I: 'static> MaxEncodedLen for Stepper<T, I>

where T::Pulse: MaxEncodedLen,

fn max_encoded_len() -> usize

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

impl<T, I> PartialEq for Stepper<T, I>

where T: Config<I>, T::Pulse: PartialEq,

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

Tests for self and other values to be equal, and is used by ==.

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

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

impl<T: Config<I>, I: 'static> Serialize for Stepper<T, I>

where T::Pulse: Serialize,

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

where __S: Serializer,

Serialize this value into the given Serde serializer.

impl<T, I> TypeInfo for Stepper<T, I>

where T::Pulse: TypeInfo + 'static, T: Config<I> + 'static, I: 'static,

type Identity = Stepper<T, I>

The type identifying for which type info is provided.

fn type_info() -> Type

Returns the static type identifier for Self.

impl<T: Config<I>, I: 'static> DecodeWithMemTracking for Stepper<T, I>

where T::Pulse: DecodeWithMemTracking,

impl<T: Config<I>, I: 'static> EncodeLike for Stepper<T, I>

where T::Pulse: Encode,

impl<T, I> Eq for Stepper<T, I>

where T: Config<I>, T::Pulse: Eq,