Trait BlockSubscriber 

pub trait BlockSubscriber:
    Send
    + Sync
    + 'static {
    type Prepared: Send;
    type PrepareBlockFut<'a>: Future<Output = Result<Self::Prepared>> + Send + 'a;
    type HandleBlockFut<'a>: Future<Output = Result<()>> + Send + 'a;

    // Required methods
    fn prepare_block<'a>(
        &'a self,
        cx: &'a BlockSubscriberContext,
    ) -> Self::PrepareBlockFut<'a>;
    fn handle_block<'a>(
        &'a self,
        cx: &'a BlockSubscriberContext,
        prepared: Self::Prepared,
    ) -> Self::HandleBlockFut<'a>;
}

Required Associated Types

type Prepared: Send

type PrepareBlockFut<'a>: Future<Output = Result<Self::Prepared>> + Send + 'a

type HandleBlockFut<'a>: Future<Output = Result<()>> + Send + 'a

Required Methods

fn prepare_block<'a>( &'a self, cx: &'a BlockSubscriberContext, ) -> Self::PrepareBlockFut<'a>

fn handle_block<'a>( &'a self, cx: &'a BlockSubscriberContext, prepared: Self::Prepared, ) -> Self::HandleBlockFut<'a>

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.

Implementations on Foreign Types

impl<T0, T1> BlockSubscriber for (T0, T1)

where T0: BlockSubscriber, T1: BlockSubscriber,

type Prepared = (<T0 as BlockSubscriber>::Prepared, <T1 as BlockSubscriber>::Prepared)

type PrepareBlockFut<'a> = Pin<Box<dyn Future<Output = Result<<(T0, T1) as BlockSubscriber>::Prepared, Error>> + Send + 'a>>

type HandleBlockFut<'a> = Pin<Box<dyn Future<Output = Result<(), Error>> + Send + 'a>>

fn prepare_block<'a>( &'a self, cx: &'a BlockSubscriberContext, ) -> Self::PrepareBlockFut<'a>

fn handle_block<'a>( &'a self, cx: &'a BlockSubscriberContext, (a, b): Self::Prepared, ) -> Self::HandleBlockFut<'a>

impl<T0, T1, T2> BlockSubscriber for (T0, T1, T2)

where T0: BlockSubscriber, T1: BlockSubscriber, T2: BlockSubscriber,

type Prepared = (<T0 as BlockSubscriber>::Prepared, <T1 as BlockSubscriber>::Prepared, <T2 as BlockSubscriber>::Prepared)

type PrepareBlockFut<'a> = Pin<Box<dyn Future<Output = Result<<(T0, T1, T2) as BlockSubscriber>::Prepared, Error>> + Send + 'a>>

type HandleBlockFut<'a> = Pin<Box<dyn Future<Output = Result<(), Error>> + Send + 'a>>

fn prepare_block<'a>( &'a self, cx: &'a BlockSubscriberContext, ) -> Self::PrepareBlockFut<'a>

fn handle_block<'a>( &'a self, cx: &'a BlockSubscriberContext, (a, b, c): Self::Prepared, ) -> Self::HandleBlockFut<'a>

impl<T0, T1, T2, T3> BlockSubscriber for (T0, T1, T2, T3)

where T0: BlockSubscriber, T1: BlockSubscriber, T2: BlockSubscriber, T3: BlockSubscriber,

type Prepared = (<T0 as BlockSubscriber>::Prepared, <T1 as BlockSubscriber>::Prepared, <T2 as BlockSubscriber>::Prepared, <T3 as BlockSubscriber>::Prepared)

type PrepareBlockFut<'a> = Pin<Box<dyn Future<Output = Result<<(T0, T1, T2, T3) as BlockSubscriber>::Prepared, Error>> + Send + 'a>>

type HandleBlockFut<'a> = Pin<Box<dyn Future<Output = Result<(), Error>> + Send + 'a>>

fn prepare_block<'a>( &'a self, cx: &'a BlockSubscriberContext, ) -> Self::PrepareBlockFut<'a>

fn handle_block<'a>( &'a self, cx: &'a BlockSubscriberContext, (a, b, c, d): Self::Prepared, ) -> Self::HandleBlockFut<'a>

impl<T0, T1, T2, T3, T4> BlockSubscriber for (T0, T1, T2, T3, T4)

where T0: BlockSubscriber, T1: BlockSubscriber, T2: BlockSubscriber, T3: BlockSubscriber, T4: BlockSubscriber,

type Prepared = (<T0 as BlockSubscriber>::Prepared, <T1 as BlockSubscriber>::Prepared, <T2 as BlockSubscriber>::Prepared, <T3 as BlockSubscriber>::Prepared, <T4 as BlockSubscriber>::Prepared)

type PrepareBlockFut<'a> = Pin<Box<dyn Future<Output = Result<<(T0, T1, T2, T3, T4) as BlockSubscriber>::Prepared, Error>> + Send + 'a>>

type HandleBlockFut<'a> = Pin<Box<dyn Future<Output = Result<(), Error>> + Send + 'a>>

fn prepare_block<'a>( &'a self, cx: &'a BlockSubscriberContext, ) -> Self::PrepareBlockFut<'a>

fn handle_block<'a>( &'a self, cx: &'a BlockSubscriberContext, (a, b, c, d, e): Self::Prepared, ) -> Self::HandleBlockFut<'a>

impl<T: BlockSubscriber> BlockSubscriber for Option<T>

type Prepared = Option<<T as BlockSubscriber>::Prepared>

type PrepareBlockFut<'a> = OptionPrepareFut<<T as BlockSubscriber>::PrepareBlockFut<'a>>

type HandleBlockFut<'a> = OptionHandleFut<<T as BlockSubscriber>::HandleBlockFut<'a>>

fn prepare_block<'a>( &'a self, cx: &'a BlockSubscriberContext, ) -> Self::PrepareBlockFut<'a>

fn handle_block<'a>( &'a self, cx: &'a BlockSubscriberContext, prepared: Self::Prepared, ) -> Self::HandleBlockFut<'a>

impl<T: BlockSubscriber> BlockSubscriber for Box<T>

type Prepared = <T as BlockSubscriber>::Prepared

type PrepareBlockFut<'a> = <T as BlockSubscriber>::PrepareBlockFut<'a>

type HandleBlockFut<'a> = <T as BlockSubscriber>::HandleBlockFut<'a>

fn prepare_block<'a>( &'a self, cx: &'a BlockSubscriberContext, ) -> Self::PrepareBlockFut<'a>

fn handle_block<'a>( &'a self, cx: &'a BlockSubscriberContext, prepared: Self::Prepared, ) -> Self::HandleBlockFut<'a>

impl<T: BlockSubscriber> BlockSubscriber for Arc<T>

type Prepared = <T as BlockSubscriber>::Prepared

type PrepareBlockFut<'a> = <T as BlockSubscriber>::PrepareBlockFut<'a>

type HandleBlockFut<'a> = <T as BlockSubscriber>::HandleBlockFut<'a>

fn prepare_block<'a>( &'a self, cx: &'a BlockSubscriberContext, ) -> Self::PrepareBlockFut<'a>

fn handle_block<'a>( &'a self, cx: &'a BlockSubscriberContext, prepared: Self::Prepared, ) -> Self::HandleBlockFut<'a>

Implementors

impl BlockSubscriber for ValidatorsResolver

type Prepared = ()

type PrepareBlockFut<'a> = Ready<Result<(), Error>>

type HandleBlockFut<'a> = Ready<Result<(), Error>>

impl BlockSubscriber for BlockSaver

type Prepared = BlockHandle

type PrepareBlockFut<'a> = Pin<Box<dyn Future<Output = Result<<BlockSaver as BlockSubscriber>::Prepared, Error>> + Send + 'a>>

type HandleBlockFut<'a> = Ready<Result<(), Error>>

impl BlockSubscriber for MetricsSubscriber

type Prepared = ()

type PrepareBlockFut<'a> = Ready<Result<(), Error>>

type HandleBlockFut<'a> = Pin<Box<dyn Future<Output = Result<(), Error>> + Send>>

impl BlockSubscriber for NoopSubscriber

type Prepared = ()

type PrepareBlockFut<'a> = Ready<Result<(), Error>>

type HandleBlockFut<'a> = Ready<Result<(), Error>>

impl<S> BlockSubscriber for ArchiveHandler<S>

where S: ArchiveSubscriber,

type Prepared = ()

type PrepareBlockFut<'a> = Ready<Result<(), Error>>

type HandleBlockFut<'a> = Pin<Box<dyn Future<Output = Result<(), Error>> + Send + 'a>>

impl<S> BlockSubscriber for ShardStateApplier<S>

where S: StateSubscriber,

type Prepared = StateApplierPrepared

type PrepareBlockFut<'a> = Pin<Box<dyn Future<Output = Result<<ShardStateApplier<S> as BlockSubscriber>::Prepared, Error>> + Send + 'a>>

type HandleBlockFut<'a> = Pin<Box<dyn Future<Output = Result<(), Error>> + Send + 'a>>

impl<T1: BlockSubscriber, T2: BlockSubscriber> BlockSubscriber for ChainSubscriber<T1, T2>

type Prepared = (<T1 as BlockSubscriber>::Prepared, <T2 as BlockSubscriber>::Prepared)

type PrepareBlockFut<'a> = Pin<Box<dyn Future<Output = Result<<ChainSubscriber<T1, T2> as BlockSubscriber>::Prepared, Error>> + Send + 'a>>

type HandleBlockFut<'a> = Pin<Box<dyn Future<Output = Result<(), Error>> + Send + 'a>>