fn import_batch<V: 'static + Verifier<B>>(
		&mut self,
		block_import: BoxBlockImport<B, Transaction>,
		verifier: V,
		origin: BlockOrigin,
		blocks: Vec<IncomingBlock<B>>,
	) -> impl Future<Output = (BoxBlockImport<B, Transaction>, V)> {
		let mut result_sender = self.result_sender.clone();
		let metrics = self.metrics.clone();

		import_many_blocks(block_import, origin, blocks, verifier, self.delay_between_blocks, metrics)
			.then(move |(imported, count, results, block_import, verifier)| {
				result_sender.blocks_processed(imported, count, results);
				future::ready((block_import, verifier))
			})
	}
/// Returns a `Future` that imports the given blocks and sends the results on
/// `self.result_sender`.
///
/// For lifetime reasons, the `BlockImport` implementation must be passed by value, and is
/// yielded back in the output once the import is finished.
Returns a `Future` that imports the given blocks and sends the results on
`self.result_sender`.

For lifetime reasons, the `BlockImport` implementation must be passed by value, and is
yielded back in the output once the import is finished.
Returns a ` Future ` that imports the given blocks and sends the results on ` self . result_sender ` . For lifetime reasons the ` BlockImport ` implementation must be passed by value and is yielded back in the output once the import is finished .
fn import_batch<V: 'static + Verifier<B>>(
		&mut self,
		block_import: BoxBlockImport<B, Transaction>,
		verifier: V,
		origin: BlockOrigin,
		blocks: Vec<IncomingBlock<B>>,
	) -> impl Future<Output = (BoxBlockImport<B, Transaction>, V)> {
		let mut result_sender = self.result_sender.clone();
		let metrics = self.metrics.clone();
		import_many_blocks(block_import, origin, blocks, verifier, self.delay_between_blocks, metrics)
			.then(move |(imported, count, results, block_import, verifier)| {
				result_sender.blocks_processed(imported, count, results);
				future::ready((block_import, verifier))
			})
	}
fn import_batch < V : ' static + Verifier < B > > ( & mut self , block_import : BoxBlockImport < B , Transaction > , verifier : V , origin : BlockOrigin , blocks : Vec < IncomingBlock < B > > , ) -> impl Future < Output = ( BoxBlockImport < B , Transaction > , V ) > { let mut result_sender = self . result_sender . clone ( ) ; let metrics = self . metrics . clone ( ) ; import_many_blocks ( block_import , origin , blocks , verifier , self . delay_between_blocks , metrics ) . then ( move | ( imported , count , results , block_import , verifier ) | { result_sender . blocks_processed ( imported , count , results ) ; future :: ready ( ( block_import , verifier ) ) } ) }
Returns a `Future` that imports the given blocks and sends the results on
`self.result_sender`.
Returns a ` Future ` that imports the given blocks and sends the results on ` self . result_sender ` .
&mut self
block_import
BoxBlockImport<B, Transaction>
verifier
V
origin
BlockOrigin
blocks
Vec<IncomingBlock<B>>
&mut self
block_import
BoxBlockImport<B, Transaction>
verifier
V
origin
BlockOrigin
blocks
Vec<IncomingBlock<B>>