Trait DebuggerHandler 

pub trait DebuggerHandler {
    // Required methods
    fn start(&mut self);
    fn job_breakpoint(
        &mut self,
        job: &Job,
        function: &RuntimeFunction,
        states: Vec<State>,
    );
    fn block_breakpoint(&mut self, block: &Block);
    fn flow_unblock_breakpoint(&mut self, flow_id: usize);
    fn send_breakpoint(
        &mut self,
        source_function_name: &str,
        source_function_id: usize,
        output_route: &str,
        value: &Value,
        destination_id: usize,
        destination_name: &str,
        io_name: &str,
        input_number: usize,
    );
    fn job_error(&mut self, job: &Job);
    fn job_completed(&mut self, job: &Job);
    fn blocks(&mut self, blocks: Vec<Block>);
    fn outputs(&mut self, output: Vec<OutputConnection>);
    fn input(&mut self, input: Input);
    fn function_list(&mut self, functions: &[RuntimeFunction]);
    fn function_states(
        &mut self,
        function: RuntimeFunction,
        function_states: Vec<State>,
    );
    fn run_state(&mut self, run_state: &RunState);
    fn message(&mut self, message: String);
    fn panic(&mut self, state: &RunState, error_message: String);
    fn debugger_exiting(&mut self);
    fn debugger_resetting(&mut self);
    fn debugger_error(&mut self, error: String);
    fn execution_starting(&mut self);
    fn execution_ended(&mut self);
    fn get_command(&mut self, state: &RunState) -> Result<DebugCommand>;
}

[DebugHandler] trait that must be implemented by clients wishing to interface with the debugger

Programs that wish to offer a debugger user interface (such as a CLI or UI) should implement this trait. The Coordinator uses it to interact with the client for debugging.

Required Methods

fn start(&mut self)

Start the debugger - which swallows the first message to initialize the connection

fn job_breakpoint( &mut self, job: &Job, function: &RuntimeFunction, states: Vec<State>, )

a breakpoint has been hit on a Job being created

fn block_breakpoint(&mut self, block: &Block)

A breakpoint set on creation of a Block matching block has been hit

fn flow_unblock_breakpoint(&mut self, flow_id: usize)

A breakpoint set on the unblocking of a flow has been hit

fn send_breakpoint( &mut self, source_function_name: &str, source_function_id: usize, output_route: &str, value: &Value, destination_id: usize, destination_name: &str, io_name: &str, input_number: usize, )

A breakpoint on sending a value from a specific function or to a specific function was hit

fn job_error(&mut self, job: &Job)

A job error occurred during execution of the flow

fn job_completed(&mut self, job: &Job)

A specific job completed

fn blocks(&mut self, blocks: Vec<Block>)

returns a set of blocks

fn outputs(&mut self, output: Vec<OutputConnection>)

returns an output’s connections

fn input(&mut self, input: Input)

returns an inputs state

fn function_list(&mut self, functions: &[RuntimeFunction])

lists all functions

fn function_states( &mut self, function: RuntimeFunction, function_states: Vec<State>, )

returns the state of a function

fn run_state(&mut self, run_state: &RunState)

returns the global run state

fn message(&mut self, message: String)

a string message from the Debugger

fn panic(&mut self, state: &RunState, error_message: String)

a panic occurred during execution

fn debugger_exiting(&mut self)

the debugger is exiting

fn debugger_resetting(&mut self)

The debugger is resetting the runtime state

fn debugger_error(&mut self, error: String)

An error occurred in the debugger

fn execution_starting(&mut self)

execution of the flow is starting

fn execution_ended(&mut self)

Execution of the flow fn execution_ended

fn get_command(&mut self, state: &RunState) -> Result<DebugCommand>

Get a command for the debugger to perform

Errors

Returns an error if the next command cannot be fetched, usually related to networking

Dyn Compatibility

This trait is dyn compatible.

In older versions of Rust, dyn compatibility was called "object safety".

Implementors