Struct ParallelMultiIndexer 

pub struct ParallelMultiIndexer<E: Debug + Send + Sync + 'static>(/* private fields */);

A parallel multi-indexer that executes all indexers concurrently.

Similar to MultiIndexer, but executes all indexers in parallel using tokio’s join. The indexers must have the same error type.

Implementations

impl<E: Debug + Send + Sync + 'static> ParallelMultiIndexer<E>

pub fn indexers(&self) -> &Vec<Box<dyn Indexer<Error = E>>>

pub fn indexers_mut(&mut self) -> &mut Vec<Box<dyn Indexer<Error = E>>>

Trait Implementations

impl<E: Debug + Send + Sync + 'static> Indexer for ParallelMultiIndexer<E>

type Error = E

fn process_block<'life0, 'life1, 'async_trait>( &'life0 mut self, block: &'life1 StreamerMessage, ) -> Pin<Box<dyn Future<Output = Result<(), Self::Error>> + Send + 'async_trait>>

where Self: 'async_trait, 'life0: 'async_trait, 'life1: 'async_trait,

Runs for every block.

fn process_transaction<'life0, 'life1, 'life2, 'async_trait>( &'life0 mut self, transaction: &'life1 IndexerTransactionWithOutcome, block: &'life2 StreamerMessage, ) -> Pin<Box<dyn Future<Output = Result<(), Self::Error>> + Send + 'async_trait>>

where Self: 'async_trait, 'life0: 'async_trait, 'life1: 'async_trait, 'life2: 'async_trait,

Runs for every transaction when it starts (not when it’s complete, see on_transaction).

fn process_receipt<'life0, 'life1, 'life2, 'async_trait>( &'life0 mut self, receipt: &'life1 IndexerExecutionOutcomeWithReceipt, block: &'life2 StreamerMessage, ) -> Pin<Box<dyn Future<Output = Result<(), Self::Error>> + Send + 'async_trait>>

where Self: 'async_trait, 'life0: 'async_trait, 'life1: 'async_trait, 'life2: 'async_trait,

Runs for every receipt, when it’s executed.

fn on_transaction<'life0, 'life1, 'life2, 'async_trait>( &'life0 mut self, transaction: &'life1 CompleteTransaction, block: &'life2 StreamerMessage, ) -> Pin<Box<dyn Future<Output = Result<(), Self::Error>> + Send + 'async_trait>>

where Self: 'async_trait, 'life0: 'async_trait, 'life1: 'async_trait, 'life2: 'async_trait,

Runs for every transaction, when it’s fully complete and all its receipts are executed. Requires preprocessing enabled in IndexerOptions.

fn on_receipt<'life0, 'life1, 'life2, 'life3, 'async_trait>( &'life0 mut self, receipt: &'life1 TransactionReceipt, tx: &'life2 IncompleteTransaction, block: &'life3 StreamerMessage, ) -> Pin<Box<dyn Future<Output = Result<(), Self::Error>> + Send + 'async_trait>>

where Self: 'async_trait, 'life0: 'async_trait, 'life1: 'async_trait, 'life2: 'async_trait, 'life3: 'async_trait,

Runs for every receipt, when it’s executed. Also contains information about the parent transaction and previous receipts. Requires preprocessing enabled in IndexerOptions.

fn process_block_end<'life0, 'life1, 'async_trait>( &'life0 mut self, block: &'life1 StreamerMessage, ) -> Pin<Box<dyn Future<Output = Result<(), Self::Error>> + Send + 'async_trait>>

where Self: 'async_trait, 'life0: 'async_trait, 'life1: 'async_trait,

Runs for every block, after all on_transaction, on_receipt, and other callbacks are called.

fn finalize<'life0, 'async_trait>( &'life0 mut self, ) -> Pin<Box<dyn Future<Output = Result<(), Self::Error>> + Send + 'async_trait>>

where Self: 'async_trait, 'life0: 'async_trait,

Runs when the indexer stops (block range ended or Ctrl+C). Useful if you don’t save the data right away on every receipt, and want to “flush” some of the generated data. This helps you make sure the program doesn’t exit before all data is saved. When you .await a run_indexer call, it won’t return until finalize returns.