Enum Event

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

A debug adapter initiated event.

Variants

Breakpoint(BreakpointEventBody)

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

Capabilities(CapabilitiesEventBody)

The event indicates that one or more capabilities have changed.

Since the capabilities are dependent on the frontend 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 frontend 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.

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.

Exited(ExitedEventBody)

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

Initialized

This event indicates that the debug adapter is ready to accept configuration requests (e.g. SetBreakpointsRequest, SetExceptionBreakpointsRequest).

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).

The sequence of events/requests is as follows:

• adapters sends ‘initialized’ event (after the ‘initialize’ request has returned)

• frontend sends zero or more ‘setBreakpoints’ requests

• frontend sends one ‘setFunctionBreakpoints’ request (if capability ‘supportsFunctionBreakpoints’ is true)

• frontend sends a ‘setExceptionBreakpoints’ request if one or more ‘exceptionBreakpointFilters’ have been defined (or if ‘supportsConfigurationDoneRequest’ is not defined or false)

• frontend sends other future configuration requests

• frontend sends one ‘configurationDone’ request to indicate the end of the configuration.

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.

This event should only be sent if the debug adapter has received a value true for the ‘supportsInvalidatedEvent’ capability of the ‘initialize’ request.

LoadedSource(LoadedSourceEventBody)

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

Module(ModuleEventBody)

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

Output(OutputEventBody)

The event indicates that the target has produced some output.

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.

ProgressEnd(ProgressEndEventBody)

The event signals the end of the progress reporting with an optional final message.

This event should only be sent if the client has passed the value true for the ‘supportsProgressReporting’ capability of the ‘initialize’ request.

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 client has passed the value true for the ‘supportsProgressReporting’ capability of the ‘initialize’ request.

ProgressUpdate(ProgressUpdateEventBody)

The event signals that the progress reporting needs to 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 client has passed the value true for the ‘supportsProgressReporting’ capability of the ‘initialize’ request.

Stopped(StoppedEventBody)

The event indicates that the execution of the debuggee has stopped due to some condition.

This can be caused by a break point previously set, a stepping request has completed, by executing a debugger statement etc.

Terminated(TerminatedEventBody)

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

Thread(ThreadEventBody)

The event indicates that a thread has started or exited.

Trait Implementations

impl Clone for Event

fn clone(&self) -> Event

Returns a duplicate of the value.

const 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<'de> Deserialize<'de> for Event

fn deserialize<__D>(__deserializer: __D) -> Result<Self, __D::Error>

where __D: Deserializer<'de>,

Deserialize this value from the given Serde deserializer.

impl From<BreakpointEventBody> for Event

fn from(body: BreakpointEventBody) -> Self

Converts to this type from the input type.

impl From<CapabilitiesEventBody> for Event

fn from(body: CapabilitiesEventBody) -> Self

Converts to this type from the input type.

impl From<ContinuedEventBody> for Event

fn from(body: ContinuedEventBody) -> Self

Converts to this type from the input type.

impl From<Event> for ProtocolMessageContent

fn from(event: Event) -> Self

Converts to this type from the input type.

impl From<ExitedEventBody> for Event

fn from(body: ExitedEventBody) -> Self

Converts to this type from the input type.

impl From<InvalidatedEventBody> for Event

fn from(body: InvalidatedEventBody) -> Self

Converts to this type from the input type.

impl From<LoadedSourceEventBody> for Event

fn from(body: LoadedSourceEventBody) -> Self

Converts to this type from the input type.

impl From<ModuleEventBody> for Event

fn from(body: ModuleEventBody) -> Self

Converts to this type from the input type.

impl From<OutputEventBody> for Event

fn from(body: OutputEventBody) -> Self

Converts to this type from the input type.

impl From<ProcessEventBody> for Event

fn from(body: ProcessEventBody) -> Self

Converts to this type from the input type.

impl From<ProgressEndEventBody> for Event

fn from(body: ProgressEndEventBody) -> Self

Converts to this type from the input type.

impl From<ProgressStartEventBody> for Event

fn from(body: ProgressStartEventBody) -> Self

Converts to this type from the input type.

impl From<ProgressUpdateEventBody> for Event

fn from(body: ProgressUpdateEventBody) -> Self

Converts to this type from the input type.

impl From<StoppedEventBody> for Event

fn from(body: StoppedEventBody) -> Self

Converts to this type from the input type.

impl From<TerminatedEventBody> for Event

fn from(body: TerminatedEventBody) -> Self

Converts to this type from the input type.

impl From<ThreadEventBody> for Event

fn from(body: ThreadEventBody) -> Self

Converts to this type from the input type.

impl PartialEq for Event

fn eq(&self, other: &Event) -> bool

Tests for self and other values to be equal, and is used by ==.

const fn ne(&self, other: &Rhs) -> bool

Tests for !=. The default implementation is almost always sufficient, and should not be overridden without very good reason.

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.

impl Eq for Event

impl StructuralPartialEq for Event