Struct ThreadedExecutionResult 

pub struct ThreadedExecutionResult<I>
where
    I: Instruction,
{
    pub program_counter: <<I as Instruction>::Reg as Register>::Type,
    pub outcome: Result<(), ExecutionError<<<I as Instruction>::Reg as Register>::Type>>,
}

Outcome of ThreadedExecutableInstruction::execute_threaded().

Unlike ExecutionResult, this is produced exactly once, by the handler that stops the chain and is not on the per-instruction path.

For performance reasons everything inside has to fit into what the platform returns in registers, in the shape of OpaqueThreadedExecutionResult. A caller that needs its fetcher after execution keeps its own copy and sets the program counter to the correct value after execution manually.

Fields

program_counter: <<I as Instruction>::Reg as Register>::Type

Program counter as of the moment execution stopped

outcome: Result<(), ExecutionError<<<I as Instruction>::Reg as Register>::Type>>

Why execution stopped

Implementations

impl<I> ThreadedExecutionResult<I>

where I: Instruction,

pub const fn stopped( program_counter: <<I as Instruction>::Reg as Register>::Type, ) -> Self

Execution stopped gracefully

pub const fn failed( program_counter: <<I as Instruction>::Reg as Register>::Type, error: ExecutionError<<<I as Instruction>::Reg as Register>::Type>, ) -> Self

Execution failed

Trait Implementations

impl<I> Debug for ThreadedExecutionResult<I>

where I: Instruction + Debug,

fn fmt(&self, f: &mut Formatter<'_>) -> Result

Formats the value using the given formatter.