Enum pallet_election_provider_multi_phase::Phase

pub enum Phase<Bn> {
    Off,
    Signed,
    Unsigned((bool, Bn)),
    Emergency,
}

Current phase of the pallet.

Variants

Off

Nothing, the election is not happening.

Signed

Signed phase is open.

Unsigned((bool, Bn))

Unsigned phase. First element is whether it is active or not, second the starting block number.

We do not yet check whether the unsigned phase is active or passive. The intent is for the blockchain to be able to declare: “I believe that there exists an adequate signed solution,” advising validators not to bother running the unsigned offchain worker.

As validator nodes are free to edit their OCW code, they could simply ignore this advisory and always compute their own solution. However, by default, when the unsigned phase is passive, the offchain workers will not bother running.

Emergency

The emergency phase. This is enabled upon a failing call to T::ElectionProvider::elect. After that, the only way to leave this phase is through a successful T::ElectionProvider::elect.

Implementations

impl<Bn: PartialEq + Eq> Phase<Bn>

pub fn is_emergency(&self) -> bool

Whether the phase is emergency or not.

pub fn is_signed(&self) -> bool

Whether the phase is signed or not.

pub fn is_unsigned(&self) -> bool

Whether the phase is unsigned or not.

pub fn is_unsigned_open_at(&self, at: Bn) -> bool

Whether the phase is unsigned and open or not, with specific start.

pub fn is_unsigned_open(&self) -> bool

Whether the phase is unsigned and open or not.

pub fn is_off(&self) -> bool

Whether the phase is off or not.

Trait Implementations

impl<Bn: Clone> Clone for Phase<Bn>

fn clone(&self) -> Phase<Bn>

Returns a copy of the value.

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

Performs copy-assignment from source.

impl<Bn: Debug> Debug for Phase<Bn>

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

Formats the value using the given formatter.

impl<Bn> Decode for Phase<Bn>

where Bn: Decode, (bool, Bn): 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<Bn> Default for Phase<Bn>

fn default() -> Self

Returns the “default value” for a type.

impl<Bn> Encode for Phase<Bn>

where Bn: Encode, (bool, Bn): 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<Bn: PartialEq> PartialEq for Phase<Bn>

fn eq(&self, other: &Phase<Bn>) -> 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<Bn> TypeInfo for Phase<Bn>

where (bool, Bn): TypeInfo + 'static, Bn: TypeInfo + 'static,

type Identity = Phase<Bn>

The type identifying for which type info is provided.

fn type_info() -> Type

Returns the static type identifier for Self.

impl<Bn: Copy> Copy for Phase<Bn>

impl<Bn> EncodeLike for Phase<Bn>

where Bn: Encode, (bool, Bn): Encode,

impl<Bn: Eq> Eq for Phase<Bn>

impl<Bn> StructuralPartialEq for Phase<Bn>