pub fn execute(
		&mut self,
		strategy: ExecutionStrategy,
	) -> Result<(Vec<u8>, B::Transaction, Option<MemoryDB<H>>), Box<Error>> {
		// We are not giving a native call and thus we are sure that the result can never be a native
		// value.
		self.execute_using_consensus_failure_handler::<_, NeverNativeValue, fn() -> _>(
			strategy.get_manager(),
			true,
			None,
		)
		.map(|(result, storage_tx, changes_tx)| (
			result.into_encoded(),
			storage_tx.expect("storage_tx is always computed when compute_tx is true; qed"),
			changes_tx,
		))
	}
/// Execute a call using the given state backend, overlayed changes, and call executor.
/// Produces a state-backend-specific "transaction" which can be used to apply the changes
/// to the backing store, such as the disk.
///
/// On an error, no prospective changes are written to the overlay.
///
/// Note: changes to code will be in place if this call is made again. For running partial
/// blocks (e.g. a transaction at a time), ensure a different method is used.
Execute a call using the given state backend, overlayed changes, and call executor.
Produces a state-backend-specific "transaction" which can be used to apply the changes
to the backing store, such as the disk.

On an error, no prospective changes are written to the overlay.

changes to code will be in place if this call is made again. For running partial
blocks , ensure a different method is used.
Execute a call using the given state backend overlayed changes and call executor . Produces a state - backend - specific " transaction " which can be used to apply the changes to the backing store such as the disk . On an error no prospective changes are written to the overlay . changes to code will be in place if this call is made again . For running partial blocks ensure a different method is used .
pub fn execute(
		&mut self,
		strategy: ExecutionStrategy,
	) -> Result<(Vec<u8>, B::Transaction, Option<MemoryDB<H>>), Box<Error>> {
		// We are not giving a native call and thus we are sure that the result can never be a native
		// value.
		self.execute_using_consensus_failure_handler::<_, NeverNativeValue, fn() -> _>(
			strategy.get_manager(),
			true,
			None,
		)
		.map(|(result, storage_tx, changes_tx)| (
			result.into_encoded(),
			storage_tx.expect("storage_tx is always computed when compute_tx is true; qed"),
			changes_tx,
		))
	}
pub fn execute ( & mut self , strategy : ExecutionStrategy , ) -> Result < ( Vec < u8 > , B :: Transaction , Option < MemoryDB < H > > ) , Box < Error > > { // We are not giving a native call and thus we are sure that the result can never be a native // value. self . execute_using_consensus_failure_handler :: < _ , NeverNativeValue , fn ( ) -> _ > ( strategy . get_manager ( ) , true , None , ) . map ( | ( result , storage_tx , changes_tx ) | ( result . into_encoded ( ) , storage_tx . expect ( " " ) , changes_tx , ) ) }
Execute a call using the given state backend, overlayed changes, and call executor.
Execute a call using the given state backend overlayed changes and call executor .
&mut self
strategy
ExecutionStrategy
&mut self
strategy
ExecutionStrategy