Enum DigestVariant

pub enum DigestVariant<T: Config<I>, I: 'static = ()> {
    Direct(Digest<T>),
    Index(Digest<T>),
    Pool(Digest<T>),
    __Ignore(PhantomData<I>),
}

Represents a generic digest variant in the commitment system.

Note: Usage of PhantomData variant in runtime will result in panic! in debug-builds. Use ChooseDigest::digest_model for safe constructions.

This enum distinguishes between the different types of digests that can exist in the pallet. It allows functions and events to operate generically over digests without losing context about their source or type.

Usage:

• Used in events like CommitPlaced, DigestInfo, etc., to convey which type of digest is being referred to.
• Enables trait and function implementations to handle multiple digest types in a type-safe and g||eneric way.

Variants

Direct(Digest<T>)

A digest that refers directly to a commitment.

Index(Digest<T>)

A digest that represents an index of multiple entries.

Pool(Digest<T>)

A digest that represents a managed pool of slots.

__Ignore(PhantomData<I>)

Phantom variant to ensure the instance parameter I is used. This variant is never constructed.

Trait Implementations

impl<T: Config<I>, I: 'static> Clone for DigestVariant<T, I>

fn clone(&self) -> Self

Returns a duplicate of the value.

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

Performs copy-assignment from source.

impl<T: Config<I>, I: 'static> Debug for DigestVariant<T, I>

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

Formats the value using the given formatter.

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

where Digest<T>: 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> Encode for DigestVariant<T, I>

where Digest<T>: 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 DigestVariant<T, I>

where Digest<T>: MaxEncodedLen,

fn max_encoded_len() -> usize

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

impl<T: Config<I>, I: 'static> PartialEq for DigestVariant<T, I>

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, I> TypeInfo for DigestVariant<T, I>

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

type Identity = DigestVariant<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 DigestVariant<T, I>

where Digest<T>: DecodeWithMemTracking,

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

where Digest<T>: Encode,

impl<T: Config<I>, I: 'static> Eq for DigestVariant<T, I>