Enum sp_finality_grandpa::ConsensusLog[−][src]

pub enum ConsensusLog<N: Codec> {
    ScheduledChange(ScheduledChange<N>),
    ForcedChange(N, ScheduledChange<N>),
    OnDisabled(AuthorityIndex),
    Pause(N),
    Resume(N),
}

Expand description

An consensus log item for GRANDPA.

Variants

ScheduledChange(ScheduledChange<N>)

Schedule an authority set change.

The earliest digest of this type in a single block will be respected, provided that there is no ForcedChange digest. If there is, then the ForcedChange will take precedence.

No change should be scheduled if one is already and the delay has not passed completely.

This should be a pure function: i.e. as long as the runtime can interpret the digest type it should return the same result regardless of the current state.

Tuple Fields of ScheduledChange

0: ScheduledChange<N>

ForcedChange(N, ScheduledChange<N>)

Force an authority set change.

Forced changes are applied after a delay of imported blocks, while pending changes are applied after a delay of finalized blocks.

The earliest digest of this type in a single block will be respected, with others ignored.

No change should be scheduled if one is already and the delay has not passed completely.

This should be a pure function: i.e. as long as the runtime can interpret the digest type it should return the same result regardless of the current state.

Tuple Fields of ForcedChange

0: N1: ScheduledChange<N>

OnDisabled(AuthorityIndex)

Note that the authority with given index is disabled until the next change.

Tuple Fields of OnDisabled

0: AuthorityIndex

Pause(N)

A signal to pause the current authority set after the given delay. After finalizing the block at delay the authorities should stop voting.

Tuple Fields of Pause

0: N

Resume(N)

A signal to resume the current authority set after the given delay. After authoring the block at delay the authorities should resume voting.

Tuple Fields of Resume

0: N

Enum sp_finality_grandpa::ConsensusLog[−][src]

Variants

Tuple Fields of ScheduledChange

Tuple Fields of ForcedChange

Tuple Fields of OnDisabled

Tuple Fields of Pause

Tuple Fields of Resume

Implementations

impl<N: Codec> ConsensusLog<N>

pub fn try_into_change(self) -> Option<ScheduledChange<N>>

pub fn try_into_forced_change(self) -> Option<(N, ScheduledChange<N>)>

pub fn try_into_pause(self) -> Option<N>

pub fn try_into_resume(self) -> Option<N>

Trait Implementations

impl<N: Clone + Codec> Clone for ConsensusLog<N>

fn clone(&self) -> ConsensusLog<N>

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

impl<N: Codec> Debug for ConsensusLog<N> where N: Debug,

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

impl<N: Codec> Decode for ConsensusLog<N> where ScheduledChange<N>: Decode, ScheduledChange<N>: Decode, N: Decode, N: Decode, ScheduledChange<N>: Decode, ScheduledChange<N>: Decode, N: Decode, N: Decode, N: Decode, N: Decode,

fn decode<__CodecInputEdqy: Input>( __codec_input_edqy: &mut __CodecInputEdqy) -> Result<Self, Error>

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

fn encoded_fixed_size() -> Option<usize>

impl<N: Codec> Encode for ConsensusLog<N> where ScheduledChange<N>: Encode, ScheduledChange<N>: Encode, N: Encode, N: Encode, ScheduledChange<N>: Encode, ScheduledChange<N>: Encode, N: Encode, N: Encode, N: Encode, N: Encode,

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

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<N: PartialEq + Codec> PartialEq<ConsensusLog<N>> for ConsensusLog<N>

fn eq(&self, other: &ConsensusLog<N>) -> bool

fn ne(&self, other: &ConsensusLog<N>) -> bool

impl<N: Codec> Serialize for ConsensusLog<N> where N: Serialize,

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

impl<N: Codec> EncodeLike<ConsensusLog<N>> for ConsensusLog<N> where ScheduledChange<N>: Encode, ScheduledChange<N>: Encode, N: Encode, N: Encode, ScheduledChange<N>: Encode, ScheduledChange<N>: Encode, N: Encode, N: Encode, N: Encode, N: Encode,

impl<N: Eq + Codec> Eq for ConsensusLog<N>

impl<N: Codec> StructuralEq for ConsensusLog<N>

impl<N: Codec> StructuralPartialEq for ConsensusLog<N>

Auto Trait Implementations

impl<N> RefUnwindSafe for ConsensusLog<N> where N: RefUnwindSafe,

impl<N> Send for ConsensusLog<N> where N: Send,

impl<N> Sync for ConsensusLog<N> where N: Sync,

impl<N> Unpin for ConsensusLog<N> where N: Unpin,

impl<N> UnwindSafe for ConsensusLog<N> where 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<Q, K> Equivalent<K> for Q where Q: Eq + ?Sized, K: Borrow<Q> + ?Sized,

pub fn equivalent(&self, key: &K) -> bool

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,

impl<N: Codec> Debug for ConsensusLog<N> where
N: Debug,

impl<N: Codec> Decode for ConsensusLog<N> where
ScheduledChange<N>: Decode,
ScheduledChange<N>: Decode,
N: Decode,
N: Decode,
ScheduledChange<N>: Decode,
ScheduledChange<N>: Decode,
N: Decode,
N: Decode,
N: Decode,
N: Decode,

fn decode<CodecInputEdqy: Input>(
codec_input_edqy: &mut __CodecInputEdqy
) -> Result<Self, Error>

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

impl<N: Codec> Encode for ConsensusLog<N> where
ScheduledChange<N>: Encode,
ScheduledChange<N>: Encode,
N: Encode,
N: Encode,
ScheduledChange<N>: Encode,
ScheduledChange<N>: Encode,
N: Encode,
N: Encode,
N: Encode,
N: Encode,

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

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

impl<N: Codec> Serialize for ConsensusLog<N> where
N: Serialize,

fn serialize<S>(&self, serializer: S) -> Result<S::Ok, S::Error> where
S: Serializer,

impl<N: Codec> EncodeLike<ConsensusLog<N>> for ConsensusLog<N> where
ScheduledChange<N>: Encode,
ScheduledChange<N>: Encode,
N: Encode,
N: Encode,
ScheduledChange<N>: Encode,
ScheduledChange<N>: Encode,
N: Encode,
N: Encode,
N: Encode,
N: Encode,

impl<N> RefUnwindSafe for ConsensusLog<N> where
N: RefUnwindSafe,

impl<N> Send for ConsensusLog<N> where
N: Send,

impl<N> Sync for ConsensusLog<N> where
N: Sync,

impl<N> Unpin for ConsensusLog<N> where
N: Unpin,

impl<N> UnwindSafe for ConsensusLog<N> where
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<Q, K> Equivalent<K> for Q where
Q: Eq + ?Sized,
K: Borrow<Q> + ?Sized,

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, 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> 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,

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

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

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

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

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

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