Enum Event 

pub enum Event {
    Initialized,
    Capabilities(CapabilitiesEventBody),
    Breakpoint(BreakpointEventBody),
    Continued(ContinuedEventBody),
    Exited(ExitedEventBody),
    Invalidated(InvalidatedEventBody),
    LoadedSource(LoadedSourceEventBody),
    Memory(MemoryEventBody),
    Module(ModuleEventBody),
    Output(OutputEventBody),
    Process(ProcessEventBody),
    ProgressEnd(ProgressEndEventBody),
    ProgressStart(ProgressStartEventBody),
    ProgressUpdate(ProgressUpdateEventBody),
    Stopped(StoppedEventBody),
    Terminated(Option<TerminatedEventBody>),
    Thread(ThreadEventBody),
    MidenUiState(Value),
}

Variants

Initialized

This event indicates that the debug adapter is ready to accept configuration requests (e.g. setBreakpoints, setExceptionBreakpoints). A debug adapter is expected to send this event when it is ready to accept configuration requests (but not before the initialize request has finished).

Specification: Initialized event

Capabilities(CapabilitiesEventBody)

The event indicates that one or more capabilities have changed. Since the capabilities are dependent on the client and its UI, it might not be possible to change that at random times (or too late). Consequently this event has a hint characteristic: a client can only be expected to make a ‘best effort’ in honouring individual capabilities but there are no guarantees. Only changed capabilities need to be included, all other capabilities keep their values.

Specification: Capabilities event

Breakpoint(BreakpointEventBody)

The event indicates that some information about a breakpoint has changed.

Specification: Breakpoint event

Continued(ContinuedEventBody)

The event indicates that the execution of the debuggee has continued. Please note: a debug adapter is not expected to send this event in response to a request that implies that execution continues, e.g. launch or continue. It is only necessary to send a continued event if there was no previous request that implied this.

Specification: Continued event

Exited(ExitedEventBody)

The event indicates that the debuggee has exited and returns its exit code.

Specification: Exited event

Invalidated(InvalidatedEventBody)

This event signals that some state in the debug adapter has changed and requires that the client needs to re-render the data snapshot previously requested. Debug adapters do not have to emit this event for runtime changes like stopped or thread events because in that case the client refetches the new state anyway. But the event can be used for example to refresh the UI after rendering formatting has changed in the debug adapter.

Specification: Invalidated event

LoadedSource(LoadedSourceEventBody)

The event indicates that some source has been added, changed, or removed from the set of all loaded sources.

Specification: LoadedSource event

Memory(MemoryEventBody)

This event indicates that some memory range has been updated. It should only be sent if the corresponding capability supportsMemoryEvent is true. Clients typically react to the event by re-issuing a readMemory request if they show the memory identified by the memoryReference and if the updated memory range overlaps the displayed range. Clients should not make assumptions how individual memory references relate to each other, so they should not assume that they are part of a single continuous address range and might overlap.

Specification: Memory event

Module(ModuleEventBody)

The event indicates that some information about a module has changed.

Specification: Module event

Output(OutputEventBody)

The event indicates that the target has produced some output.

Specification: Output event

Process(ProcessEventBody)

The event indicates that the debugger has begun debugging a new process. Either one that it has launched, or one that it has attached to.

Specification: Process event

ProgressEnd(ProgressEndEventBody)

The event signals the end of the progress reporting with a final message. This event should only be sent if the corresponding capability supportsProgressReporting is true.

Specification: ProgressEnd event

ProgressStart(ProgressStartEventBody)

The event signals that a long running operation is about to start and provides additional information for the client to set up a corresponding progress and cancellation UI. The client is free to delay the showing of the UI in order to reduce flicker. This event should only be sent if the corresponding capability supportsProgressReporting is true.

Specification: ProgressStart event

ProgressUpdate(ProgressUpdateEventBody)

The event signals that the progress reporting needs to be updated with a new message and/or percentage. The client does not have to update the UI immediately, but the clients needs to keep track of the message and/or percentage values. This event should only be sent if the corresponding capability supportsProgressReporting is true.

Specification: ProgressUpdate event

Stopped(StoppedEventBody)

The event indicates that the execution of the debuggee has stopped due to some condition. This can be caused by a breakpoint previously set, a stepping request has completed, by executing a debugger statement etc.

Specification: Stopped event

Terminated(Option<TerminatedEventBody>)

The event indicates that debugging of the debuggee has terminated. This does not mean that the debuggee itself has exited.

Specification: Terminated event

Thread(ThreadEventBody)

The event indicates that a thread has started or exited.

Specification: Thread event

MidenUiState(Value)

Custom Miden event: server-pushed bundled UI state snapshot.

Emitted immediately before a Stopped event so the DAP client can update its UI from the snapshot without an extra evaluate round-trip.

Trait Implementations

impl Clone for Event

fn clone(&self) -> Event

Returns a duplicate of the value.

fn clone_from(&mut self, source: &Self)

Performs copy-assignment from source.

impl Debug for Event

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

Formats the value using the given formatter.

impl Serialize for Event

fn serialize<__S>(&self, __serializer: __S) -> Result<__S::Ok, __S::Error>

where __S: Serializer,

Serialize this value into the given Serde serializer.