Enum cumulus_primitives_core::relay_chain::v8::CoreState

pub enum CoreState<H = H256, N = u32> {
    Occupied(OccupiedCore<H, N>),
    Scheduled(ScheduledCore),
    Free,
}

The state of a particular availability core.

Variants

Occupied(OccupiedCore<H, N>)

The core is currently occupied.

Scheduled(ScheduledCore)

The core is currently free, with a para scheduled and given the opportunity to occupy.

If a particular Collator is required to author this block, that is also present in this variant.

Free

The core is currently free and there is nothing scheduled. This can be the case for parathread cores when there are no parathread blocks queued. Parachain cores will never be left idle.

Implementations

impl<N> CoreState<N>

pub fn para_id(&self) -> Option<Id>

👎Deprecated: para_id will be removed. Use ClaimQueue to query the scheduled para_id instead.

Returns the scheduled ParaId for the core or None if nothing is scheduled.

This function is deprecated. ClaimQueue should be used to obtain the scheduled ParaIds for each core.

pub fn is_occupied(&self) -> bool

Is this core state Self::Occupied?

Trait Implementations

impl<H, N> Clone for CoreState<H, N>

where H: Clone, N: Clone,

fn clone(&self) -> CoreState<H, N>

Returns a copy of the value.

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

Performs copy-assignment from source.

impl<H, N> Debug for CoreState<H, N>

where H: Debug, N: Debug,

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

Formats the value using the given formatter.

impl<H, N> Decode for CoreState<H, N>

where OccupiedCore<H, N>: Decode,

fn decode<__CodecInputEdqy>( __codec_input_edqy: &mut __CodecInputEdqy, ) -> Result<CoreState<H, N>, Error>

where __CodecInputEdqy: Input,

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<H, N> Encode for CoreState<H, N>

where OccupiedCore<H, N>: Encode,

fn size_hint(&self) -> usize

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

fn encode_to<__CodecOutputEdqy>( &self, __codec_dest_edqy: &mut __CodecOutputEdqy, )

where __CodecOutputEdqy: Output + ?Sized,

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<H> From<CoreState<H>> for CoreState<H>

where H: Copy,

fn from(value: CoreState<H>) -> CoreState<H>

Converts to this type from the input type.

impl<H, N> PartialEq for CoreState<H, N>

where H: PartialEq, N: PartialEq,

fn eq(&self, other: &CoreState<H, N>) -> 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<H, N> TypeInfo for CoreState<H, N>

where OccupiedCore<H, N>: TypeInfo + 'static, H: TypeInfo + 'static, N: TypeInfo + 'static,

type Identity = CoreState<H, N>

The type identifying for which type info is provided.

fn type_info() -> Type

Returns the static type identifier for Self.

impl<H, N> EncodeLike for CoreState<H, N>

where OccupiedCore<H, N>: Encode,

impl<H, N> StructuralPartialEq for CoreState<H, N>