Struct cumulus_primitives_core::relay_chain::v1::OccupiedCore[−][src]

pub struct OccupiedCore<H = H256, N = u32> {
    pub next_up_on_available: Option<ScheduledCore>,
    pub occupied_since: N,
    pub time_out_at: N,
    pub next_up_on_time_out: Option<ScheduledCore>,
    pub availability: BitVec<Lsb0, u8>,
    pub group_responsible: GroupIndex,
    pub candidate_hash: CandidateHash,
    pub candidate_descriptor: CandidateDescriptor<H>,
}

Expand description

Information about a core which is currently occupied.

Fields

next_up_on_available: Option<ScheduledCore>

If this core is freed by availability, this is the assignment that is next up on this core, if any. None if there is nothing queued for this core.

occupied_since: N

The relay-chain block number this began occupying the core at.

time_out_at: N

The relay-chain block this will time-out at, if any.

next_up_on_time_out: Option<ScheduledCore>

If this core is freed by being timed-out, this is the assignment that is next up on this core. None if there is nothing queued for this core or there is no possibility of timing out.

availability: BitVec<Lsb0, u8>

A bitfield with 1 bit for each validator in the set. 1 bits mean that the corresponding validators has attested to availability on-chain. A 2/3+ majority of 1 bits means that this will be available.

group_responsible: GroupIndex

The group assigned to distribute availability pieces of this candidate.

candidate_hash: CandidateHash

The hash of the candidate occupying the core.

candidate_descriptor: CandidateDescriptor<H>

The descriptor of the candidate occupying the core.

Struct cumulus_primitives_core::relay_chain::v1::OccupiedCore[−][src]

Fields

Implementations

impl<H, N> OccupiedCore<H, N>

pub fn para_id(&self) -> Id

Trait Implementations

impl<H, N> Clone for OccupiedCore<H, N> where H: Clone, N: Clone,

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

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

impl<H, N> Debug for OccupiedCore<H, N> where H: Debug, N: Debug,

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

impl<H, N> Decode for OccupiedCore<H, N> where N: Decode, CandidateDescriptor<H>: Decode,

pub fn decode<__CodecInputEdqy>( __codec_input_edqy: &mut __CodecInputEdqy) -> Result<OccupiedCore<H, N>, Error> where __CodecInputEdqy: Input,

fn skip<I>(input: &mut I) -> Result<(), Error> where I: Input,

fn encoded_fixed_size() -> Option<usize>

impl<H, N> Encode for OccupiedCore<H, N> where N: Encode, CandidateDescriptor<H>: Encode,

pub fn encode_to<__CodecOutputEdqy>( &self, __codec_dest_edqy: &mut __CodecOutputEdqy) where __CodecOutputEdqy: Output + ?Sized,

fn size_hint(&self) -> usize

fn encode(&self) -> Vec<u8, Global>

fn using_encoded<R, F>(&self, f: F) -> R where F: FnOnce(&[u8]) -> R,

fn encoded_size(&self) -> usize

impl<H, N> MallocSizeOf for OccupiedCore<H, N> where H: MallocSizeOf, N: MallocSizeOf,

pub fn size_of(&self, ops: &mut MallocSizeOfOps) -> usize

fn constant_size() -> Option<usize>

impl<H, N> PartialEq<OccupiedCore<H, N>> for OccupiedCore<H, N> where H: PartialEq<H>, N: PartialEq<N>,

pub fn eq(&self, other: &OccupiedCore<H, N>) -> bool

pub fn ne(&self, other: &OccupiedCore<H, N>) -> bool

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

type Identity = OccupiedCore<H, N>

pub fn type_info() -> Type<MetaForm>

impl<H, N> EncodeLike<OccupiedCore<H, N>> for OccupiedCore<H, N> where N: Encode, CandidateDescriptor<H>: Encode,

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

Auto Trait Implementations

impl<H, N> RefUnwindSafe for OccupiedCore<H, N> where H: RefUnwindSafe, N: RefUnwindSafe,

impl<H, N> Send for OccupiedCore<H, N> where H: Send, N: Send,

impl<H, N> Sync for OccupiedCore<H, N> where H: Sync, N: Sync,

impl<H, N> Unpin for OccupiedCore<H, N> where H: Unpin, N: Unpin,

impl<H, N> UnwindSafe for OccupiedCore<H, N> where H: UnwindSafe, N: UnwindSafe,

Blanket Implementations

impl<T> Any for T where T: 'static + ?Sized,

pub fn type_id(&self) -> TypeId

impl<T> Borrow<T> for T where T: ?Sized,

pub fn borrow(&self) -> &T

impl<T> BorrowMut<T> for T where T: ?Sized,

pub fn borrow_mut(&mut self) -> &mut T

impl<T> CheckedConversion for T

fn checked_from<T>(t: T) -> Option<Self> where Self: TryFrom<T>,

fn checked_into<T>(self) -> Option<T> where Self: TryInto<T>,

impl<T> Conv for T

fn conv<T>(self) -> T where Self: Into<T>,

impl<T> Conv for T

fn conv<T>(self) -> T where Self: Into<T>,

impl<T> DecodeAll for T where T: Decode,

pub fn decode_all(input: &[u8]) -> Result<T, Error>

impl<T> DecodeLimit for T where T: Decode,

pub fn decode_all_with_depth_limit(limit: u32, input: &[u8]) -> Result<T, Error>

pub fn decode_and_advance_with_depth_limit<I>( limit: u32, input: &mut I) -> Result<T, Error> where I: Input,

pub fn decode_with_depth_limit(limit: u32, input: &[u8]) -> Result<T, Error>

impl<T> Downcast for T where T: Any,

pub fn into_any(self: Box<T, Global>) -> Box<dyn Any + 'static, Global>

pub fn into_any_rc(self: Rc<T>) -> Rc<dyn Any + 'static>

pub fn as_any(&self) -> &(dyn Any + 'static)

pub fn as_any_mut(&mut self) -> &mut (dyn Any + 'static)

impl<T> DowncastSync for T where T: Any + Send + Sync,

pub fn into_any_arc(self: Arc<T>) -> Arc<dyn Any + Sync + Send + 'static>

impl<T> DynClone for T where T: Clone,

pub fn __clone_box(&self, Private) -> *mut ()

impl<T> EncodeAs<T> for T where T: Encode,

pub fn encode_as(&self) -> Vec<u8, Global>

impl<T> FmtForward for T

fn fmt_binary(self) -> FmtBinary<Self> where Self: Binary,

fn fmt_display(self) -> FmtDisplay<Self> where Self: Display,

fn fmt_lower_exp(self) -> FmtLowerExp<Self> where Self: LowerExp,

fn fmt_lower_hex(self) -> FmtLowerHex<Self> where Self: LowerHex,

fn fmt_octal(self) -> FmtOctal<Self> where Self: Octal,

fn fmt_pointer(self) -> FmtPointer<Self> where Self: Pointer,

fn fmt_upper_exp(self) -> FmtUpperExp<Self> where Self: UpperExp,

fn fmt_upper_hex(self) -> FmtUpperHex<Self> where Self: UpperHex,

impl<T> From<T> for T

pub fn from(t: T) -> T

impl<H, N> Clone for OccupiedCore<H, N> where
H: Clone,
N: Clone,

impl<H, N> Debug for OccupiedCore<H, N> where
H: Debug,
N: Debug,

impl<H, N> Decode for OccupiedCore<H, N> where
N: Decode,
CandidateDescriptor<H>: Decode,

pub fn decode<CodecInputEdqy>(
codec_input_edqy: &mut CodecInputEdqy
) -> Result<OccupiedCore<H, N>, Error> where
CodecInputEdqy: Input,

fn skip<I>(input: &mut I) -> Result<(), Error> where
I: Input,

impl<H, N> Encode for OccupiedCore<H, N> where
N: Encode,
CandidateDescriptor<H>: Encode,

pub fn encode_to<CodecOutputEdqy>(
&self,
codec_dest_edqy: &mut CodecOutputEdqy
) where
CodecOutputEdqy: Output + ?Sized,

fn using_encoded<R, F>(&self, f: F) -> R where
F: FnOnce(&[u8 ]) -> R,

impl<H, N> MallocSizeOf for OccupiedCore<H, N> where
H: MallocSizeOf,
N: MallocSizeOf,

impl<H, N> PartialEq<OccupiedCore<H, N>> for OccupiedCore<H, N> where
H: PartialEq<H>,
N: PartialEq<N>,

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

impl<H, N> EncodeLike<OccupiedCore<H, N>> for OccupiedCore<H, N> where
N: Encode,
CandidateDescriptor<H>: Encode,

impl<H, N> RefUnwindSafe for OccupiedCore<H, N> where
H: RefUnwindSafe,
N: RefUnwindSafe,

impl<H, N> Send for OccupiedCore<H, N> where
H: Send,
N: Send,

impl<H, N> Sync for OccupiedCore<H, N> where
H: Sync,
N: Sync,

impl<H, N> Unpin for OccupiedCore<H, N> where
H: Unpin,
N: Unpin,

impl<H, N> UnwindSafe for OccupiedCore<H, N> where
H: UnwindSafe,
N: UnwindSafe,

impl<T> Any for T where
T: 'static + ?Sized,

impl<T> Borrow<T> for T where
T: ?Sized,

impl<T> BorrowMut<T> for T where
T: ?Sized,

fn checked_from<T>(t: T) -> Option<Self> where
Self: TryFrom<T>,

fn checked_into<T>(self) -> Option<T> where
Self: TryInto<T>,

fn conv<T>(self) -> T where
Self: Into<T>,

fn conv<T>(self) -> T where
Self: Into<T>,

impl<T> DecodeAll for T where
T: Decode,

pub fn decode_all(input: &[u8 ]) -> Result<T, Error>

impl<T> DecodeLimit for T where
T: Decode,

pub fn decode_all_with_depth_limit(limit: u32, input: &[u8 ]) -> Result<T, Error>

pub fn decode_and_advance_with_depth_limit<I>(
limit: u32,
input: &mut I
) -> Result<T, Error> where
I: Input,

pub fn decode_with_depth_limit(limit: u32, input: &[u8 ]) -> Result<T, Error>

impl<T> Downcast for T where
T: Any,

impl<T> DowncastSync for T where
T: Any + Send + Sync,

impl<T> DynClone for T where
T: Clone,

impl<T> EncodeAs<T> for T where
T: Encode,

fn fmt_binary(self) -> FmtBinary<Self> where
Self: Binary,

fn fmt_display(self) -> FmtDisplay<Self> where
Self: Display,

fn fmt_lower_exp(self) -> FmtLowerExp<Self> where
Self: LowerExp,

fn fmt_lower_hex(self) -> FmtLowerHex<Self> where
Self: LowerHex,

fn fmt_octal(self) -> FmtOctal<Self> where
Self: Octal,

fn fmt_pointer(self) -> FmtPointer<Self> where
Self: Pointer,

fn fmt_upper_exp(self) -> FmtUpperExp<Self> where
Self: UpperExp,

fn fmt_upper_hex(self) -> FmtUpperHex<Self> where
Self: UpperHex,

impl<T> Hashable for T where
T: Codec,

pub fn blake2_128(&self) -> [u8 ; 16]

pub fn blake2_256(&self) -> [u8 ; 32]

pub fn twox_128(&self) -> [u8 ; 16]

pub fn twox_256(&self) -> [u8 ; 32]

impl<T, U> Into<U> for T where
U: From<T>,

impl<T, Outer> IsWrappedBy<Outer> for T where
Outer: AsRef<T> + AsMut<T> + From<T>,
T: From<Outer>,

impl<T> KeyedVec for T where
T: Codec,

pub fn to_keyed_vec(&self, prepend_key: &[u8 ]) -> Vec<u8, Global>

impl<T> MallocSizeOfExt for T where
T: MallocSizeOf,

impl<T> Pipe for T where
T: ?Sized,

fn pipe_ref<'a, R>(&'a self, func: impl FnOnce(&'a Self) -> R) -> R where
R: 'a,

fn pipe_ref_mut<'a, R>(&'a mut self, func: impl FnOnce(&'a mut Self) -> R) -> R where
R: 'a,

fn pipe_borrow<'a, B, R>(&'a self, func: impl FnOnce(&'a B) -> R) -> R where
Self: Borrow<B>,
B: 'a + ?Sized,
R: 'a,

fn pipe_borrow_mut<'a, B, R>(
&'a mut self,
func: impl FnOnce(&'a mut B) -> R
) -> R where
Self: BorrowMut<B>,
B: 'a + ?Sized,
R: 'a,

fn pipe_as_ref<'a, U, R>(&'a self, func: impl FnOnce(&'a U) -> R) -> R where
Self: AsRef<U>,
U: 'a + ?Sized,
R: 'a,

fn pipe_as_mut<'a, U, R>(&'a mut self, func: impl FnOnce(&'a mut U) -> R) -> R where
Self: AsMut<U>,
U: 'a + ?Sized,
R: 'a,

fn pipe_deref<'a, T, R>(&'a self, func: impl FnOnce(&'a T) -> R) -> R where
Self: Deref<Target = T>,
T: 'a + ?Sized,
R: 'a,

fn pipe_deref_mut<'a, T, R>(
&'a mut self,
func: impl FnOnce(&'a mut T) -> R
) -> R where
Self: DerefMut<Target = T> + Deref,
T: 'a + ?Sized,
R: 'a,

fn pipe_as_ref<'a, T, R>(&'a self, func: impl FnOnce(&'a T) -> R) -> R where
Self: AsRef<T>,
T: 'a,
R: 'a,

fn pipe_as_mut<'a, T, R>(&'a mut self, func: impl FnOnce(&'a mut T) -> R) -> R where
Self: AsMut<T>,
T: 'a,
R: 'a,

fn pipe_borrow<'a, T, R>(&'a self, func: impl FnOnce(&'a T) -> R) -> R where
Self: Borrow<T>,
T: 'a,
R: 'a,

fn pipe_borrow_mut<'a, T, R>(
&'a mut self,
func: impl FnOnce(&'a mut T) -> R
) -> R where
Self: BorrowMut<T>,
T: 'a,
R: 'a,

fn pipe_deref<'a, R>(&'a self, func: impl FnOnce(&'a Self::Target) -> R) -> R where
Self: Deref,
R: 'a,

fn pipe_deref_mut<'a, R>(
&'a mut self,
func: impl FnOnce(&'a mut Self::Target) -> R
) -> R where
Self: DerefMut,
R: 'a,

fn pipe_ref<'a, R>(&'a self, func: impl FnOnce(&'a Self) -> R) -> R where
R: 'a,

fn pipe_mut<'a, R>(&'a mut self, func: impl FnOnce(&'a mut Self) -> R) -> R where
R: 'a,

fn saturated_from<T>(t: T) -> Self where
Self: UniqueSaturatedFrom<T>,

fn saturated_into<T>(self) -> T where
Self: UniqueSaturatedInto<T>,

fn tap_borrow<B>(self, func: impl FnOnce(&B)) -> Self where
Self: Borrow<B>,
B: ?Sized,

fn tap_borrow_mut<B>(self, func: impl FnOnce(&mut B)) -> Self where
Self: BorrowMut<B>,
B: ?Sized,

fn tap_ref<R>(self, func: impl FnOnce(&R)) -> Self where
Self: AsRef<R>,
R: ?Sized,

fn tap_ref_mut<R>(self, func: impl FnOnce(&mut R)) -> Self where
Self: AsMut<R>,
R: ?Sized,

fn tap_deref<T>(self, func: impl FnOnce(&T)) -> Self where
Self: Deref<Target = T>,
T: ?Sized,

fn tap_deref_mut<T>(self, func: impl FnOnce(&mut T)) -> Self where
Self: DerefMut<Target = T> + Deref,
T: ?Sized,