Trait Variant 

pub trait Variant:
    Clone
    + Send
    + Sync
    + 'static {
    type Block: Block<Digest = <Self::ApplicationBlock as Digestible>::Digest> + Into<Self::StoredBlock> + Clone;
    type ApplicationBlock: Block + Clone;
    type StoredBlock: Block<Digest = <Self::Block as Digestible>::Digest> + Into<Self::Block> + Clone + Codec<Cfg = <Self::Block as Read>::Cfg>;
    type Commitment: Digest;

    // Required methods
    fn commitment(block: &Self::Block) -> Self::Commitment;
    fn commitment_to_inner(
        commitment: Self::Commitment,
    ) -> <Self::Block as Digestible>::Digest;
    fn parent_commitment(block: &Self::Block) -> Self::Commitment;
    fn into_inner(block: Self::Block) -> Self::ApplicationBlock;
}

A marker trait describing the types used by a variant of Marshal.

Required Associated Types

type Block: Block<Digest = <Self::ApplicationBlock as Digestible>::Digest> + Into<Self::StoredBlock> + Clone

The working block type of marshal, supporting the consensus commitment.

Must be convertible to StoredBlock via Into for archival.

type ApplicationBlock: Block + Clone

The application block type.

type StoredBlock: Block<Digest = <Self::Block as Digestible>::Digest> + Into<Self::Block> + Clone + Codec<Cfg = <Self::Block as Read>::Cfg>

The type of block stored in the archive.

Must be convertible back to the working block type via Into.

type Commitment: Digest

The Digest type used by consensus.

Required Methods

fn commitment(block: &Self::Block) -> Self::Commitment

Computes the consensus commitment for a block.

The commitment is what validators sign over during consensus.

Together with Variant::commitment_to_inner, implementations must satisfy: commitment_to_inner(commitment(block)) == block.digest().

fn commitment_to_inner( commitment: Self::Commitment, ) -> <Self::Block as Digestible>::Digest

Extracts the block digest from a consensus commitment.

For blocks/certificates accepted by marshal in this variant instance, the digest must uniquely determine the commitment. In other words, there should not be two accepted commitments with the same inner digest.

fn parent_commitment(block: &Self::Block) -> Self::Commitment

Returns the parent commitment referenced by block.

fn into_inner(block: Self::Block) -> Self::ApplicationBlock

Converts a working block to an application block.

This conversion cannot use Into due to orphan rules when Block wraps ApplicationBlock (e.g., CodedBlock<B, C, H> -> B).

Dyn Compatibility

This trait is not dyn compatible.

In older versions of Rust, dyn compatibility was called "object safety", so this trait is not object safe.

Implementors

impl<B> Variant for Standard<B>

where B: Block,

type ApplicationBlock = B

type Block = B

type StoredBlock = B

type Commitment = <B as Digestible>::Digest

impl<B, C, H, P> Variant for Coding<B, C, H, P>

where B: CertifiableBlock<Context = Context<Commitment, P>>, C: CodingScheme, H: Hasher, P: PublicKey,

type ApplicationBlock = B

type Block = CodedBlock<B, C, H>

type StoredBlock = StoredCodedBlock<B, C, H>

type Commitment = Commitment