git.iko.soy/helix
on master help sign in
dap: Split types off into types.rs
2d1ae2eBlaž Hrastnik
helix-dap/src/client.rs+1−322
compare with master
unifiedsplit
@@ -1,5 +1,6 @@
1use crate::{
1use crate::{
2 transport::{Event, Payload, Request, Response, Transport},
2 transport::{Event, Payload, Request, Response, Transport},
3+ types::*,
3 Result,
4 Result,
4};
5};
5use log::{error, info};
6use log::{error, info};
@@ -29,328 +30,6 @@ use tokio::{
29 time,
30 time,
30};
31};
31
32
32−#[derive(Debug, PartialEq, Clone, Deserialize, Serialize)]
33−#[serde(rename_all = "camelCase")]
34−pub struct ColumnDescriptor {
35− pub attribute_name: String,
36− pub label: String,
37− pub format: Option<String>,
38− #[serde(rename = "type")]
39− pub col_type: Option<String>,
40− pub width: Option<usize>,
41−}
42−
43−#[derive(Debug, PartialEq, Clone, Deserialize, Serialize)]
44−#[serde(rename_all = "camelCase")]
45−pub struct ExceptionBreakpointsFilter {
46− pub filter: String,
47− pub label: String,
48− pub description: Option<String>,
49− pub default: Option<bool>,
50− pub supports_condition: Option<bool>,
51− pub condition_description: Option<String>,
52−}
53−
54−#[derive(Debug, PartialEq, Clone, Deserialize, Serialize)]
55−#[serde(rename_all = "camelCase")]
56−pub struct DebuggerCapabilities {
57− pub supports_configuration_done_request: Option<bool>,
58− pub supports_function_breakpoints: Option<bool>,
59− pub supports_conditional_breakpoints: Option<bool>,
60− pub supports_hit_conditional_breakpoints: Option<bool>,
61− pub supports_evaluate_for_hovers: Option<bool>,
62− pub supports_step_back: Option<bool>,
63− pub supports_set_variable: Option<bool>,
64− pub supports_restart_frame: Option<bool>,
65− pub supports_goto_targets_request: Option<bool>,
66− pub supports_step_in_targets_request: Option<bool>,
67− pub supports_completions_request: Option<bool>,
68− pub supports_modules_request: Option<bool>,
69− pub supports_restart_request: Option<bool>,
70− pub supports_exception_options: Option<bool>,
71− pub supports_value_formatting_options: Option<bool>,
72− pub supports_exception_info_request: Option<bool>,
73− pub support_terminate_debuggee: Option<bool>,
74− pub support_suspend_debuggee: Option<bool>,
75− pub supports_delayed_stack_trace_loading: Option<bool>,
76− pub supports_loaded_sources_request: Option<bool>,
77− pub supports_log_points: Option<bool>,
78− pub supports_terminate_threads_request: Option<bool>,
79− pub supports_set_expression: Option<bool>,
80− pub supports_terminate_request: Option<bool>,
81− pub supports_data_breakpoints: Option<bool>,
82− pub supports_read_memory_request: Option<bool>,
83− pub supports_write_memory_request: Option<bool>,
84− pub supports_disassemble_request: Option<bool>,
85− pub supports_cancel_request: Option<bool>,
86− pub supports_breakpoint_locations_request: Option<bool>,
87− pub supports_clipboard_context: Option<bool>,
88− pub supports_stepping_granularity: Option<bool>,
89− pub supports_instruction_breakpoints: Option<bool>,
90− pub supports_exception_filter_options: Option<bool>,
91− pub exception_breakpoint_filters: Option<Vec<ExceptionBreakpointsFilter>>,
92− pub completion_trigger_characters: Option<Vec<String>>,
93− pub additional_module_columns: Option<Vec<ColumnDescriptor>>,
94− pub supported_checksum_algorithms: Option<Vec<String>>,
95−}
96−
97−impl std::ops::Deref for DebuggerCapabilities {
98− type Target = Option<bool>;
99−
100− fn deref(&self) -> &Self::Target {
101− &self.supports_exception_options
102− }
103−}
104−
105−#[derive(Debug, PartialEq, Clone, Deserialize, Serialize)]
106−#[serde(rename_all = "camelCase")]
107−struct InitializeArguments {
108− #[serde(rename = "clientID")]
109− client_id: Option<String>,
110− client_name: Option<String>,
111− #[serde(rename = "adapterID")]
112− adapter_id: String,
113− locale: Option<String>,
114− #[serde(rename = "linesStartAt1")]
115− lines_start_at_one: Option<bool>,
116− #[serde(rename = "columnsStartAt1")]
117− columns_start_at_one: Option<bool>,
118− path_format: Option<String>,
119− supports_variable_type: Option<bool>,
120− supports_variable_paging: Option<bool>,
121− supports_run_in_terminal_request: Option<bool>,
122− supports_memory_references: Option<bool>,
123− supports_progress_reporting: Option<bool>,
124− supports_invalidated_event: Option<bool>,
125−}
126−
127−#[derive(Debug, PartialEq, Clone, Deserialize, Serialize)]
128−#[serde(rename_all = "camelCase")]
129−pub struct Checksum {
130− pub algorithm: String,
131− pub checksum: String,
132−}
133−
134−#[derive(Debug, PartialEq, Clone, Deserialize, Serialize)]
135−#[serde(rename_all = "camelCase")]
136−pub struct Source {
137− pub name: Option<String>,
138− pub path: Option<String>,
139− pub source_reference: Option<usize>,
140− pub presentation_hint: Option<String>,
141− pub origin: Option<String>,
142− pub sources: Option<Vec<Source>>,
143− pub adapter_data: Option<Value>,
144− pub checksums: Option<Vec<Checksum>>,
145−}
146−
147−#[derive(Debug, PartialEq, Clone, Deserialize, Serialize)]
148−#[serde(rename_all = "camelCase")]
149−pub struct SourceBreakpoint {
150− pub line: usize,
151− pub column: Option<usize>,
152− pub condition: Option<String>,
153− pub hit_condition: Option<String>,
154− pub log_message: Option<String>,
155−}
156−
157−#[derive(Debug, PartialEq, Clone, Deserialize, Serialize)]
158−#[serde(rename_all = "camelCase")]
159−struct SetBreakpointsArguments {
160− source: Source,
161− breakpoints: Option<Vec<SourceBreakpoint>>,
162− // lines is deprecated
163− source_modified: Option<bool>,
164−}
165−
166−#[derive(Debug, PartialEq, Clone, Deserialize, Serialize)]
167−#[serde(rename_all = "camelCase")]
168−pub struct Breakpoint {
169− pub id: Option<usize>,
170− pub verified: bool,
171− pub message: Option<String>,
172− pub source: Option<Source>,
173− pub line: Option<usize>,
174− pub column: Option<usize>,
175− pub end_line: Option<usize>,
176− pub end_column: Option<usize>,
177− pub instruction_reference: Option<String>,
178− pub offset: Option<usize>,
179−}
180−
181−#[derive(Debug, PartialEq, Clone, Deserialize, Serialize)]
182−#[serde(rename_all = "camelCase")]
183−struct SetBreakpointsResponseBody {
184− breakpoints: Option<Vec<Breakpoint>>,
185−}
186−
187−#[derive(Debug, PartialEq, Clone, Deserialize, Serialize)]
188−#[serde(rename_all = "camelCase")]
189−struct ContinueArguments {
190− thread_id: usize,
191−}
192−
193−#[derive(Debug, PartialEq, Clone, Deserialize, Serialize)]
194−#[serde(rename_all = "camelCase")]
195−struct ContinueResponseBody {
196− all_threads_continued: Option<bool>,
197−}
198−
199−#[derive(Debug, PartialEq, Clone, Deserialize, Serialize)]
200−#[serde(rename_all = "camelCase")]
201−struct StackFrameFormat {
202− parameters: Option<bool>,
203− parameter_types: Option<bool>,
204− parameter_names: Option<bool>,
205− parameter_values: Option<bool>,
206− line: Option<bool>,
207− module: Option<bool>,
208− include_all: Option<bool>,
209−}
210−
211−#[derive(Debug, PartialEq, Clone, Deserialize, Serialize)]
212−#[serde(rename_all = "camelCase")]
213−struct StackTraceArguments {
214− thread_id: usize,
215− start_frame: Option<usize>,
216− levels: Option<usize>,
217− format: Option<StackFrameFormat>,
218−}
219−
220−#[derive(Debug, PartialEq, Clone, Deserialize, Serialize)]
221−#[serde(rename_all = "camelCase")]
222−pub struct StackFrame {
223− pub id: usize,
224− pub name: String,
225− pub source: Option<Source>,
226− pub line: usize,
227− pub column: usize,
228− pub end_line: Option<usize>,
229− pub end_column: Option<usize>,
230− pub can_restart: Option<bool>,
231− pub instruction_pointer_reference: Option<String>,
232− pub module_id: Option<Value>,
233− pub presentation_hint: Option<String>,
234−}
235−
236−#[derive(Debug, PartialEq, Clone, Deserialize, Serialize)]
237−#[serde(rename_all = "camelCase")]
238−struct StackTraceResponseBody {
239− total_frames: Option<usize>,
240− stack_frames: Vec<StackFrame>,
241−}
242−
243−#[derive(Debug, PartialEq, Clone, Deserialize, Serialize)]
244−#[serde(rename_all = "camelCase")]
245−pub struct Thread {
246− pub id: usize,
247− pub name: String,
248−}
249−
250−#[derive(Debug, PartialEq, Clone, Deserialize, Serialize)]
251−#[serde(rename_all = "camelCase")]
252−struct ThreadsResponseBody {
253− threads: Vec<Thread>,
254−}
255−
256−#[derive(Debug, PartialEq, Clone, Deserialize, Serialize)]
257−#[serde(rename_all = "camelCase")]
258−struct ScopesArguments {
259− frame_id: usize,
260−}
261−
262−#[derive(Debug, PartialEq, Clone, Deserialize, Serialize)]
263−#[serde(rename_all = "camelCase")]
264−pub struct Scope {
265− pub name: String,
266− pub presentation_hint: Option<String>,
267− pub variables_reference: usize,
268− pub named_variables: Option<usize>,
269− pub indexed_variables: Option<usize>,
270− pub expensive: bool,
271− pub source: Option<Source>,
272− pub line: Option<usize>,
273− pub column: Option<usize>,
274− pub end_line: Option<usize>,
275− pub end_column: Option<usize>,
276−}
277−
278−#[derive(Debug, PartialEq, Clone, Deserialize, Serialize)]
279−#[serde(rename_all = "camelCase")]
280−struct ScopesResponseBody {
281− scopes: Vec<Scope>,
282−}
283−
284−#[derive(Debug, PartialEq, Clone, Deserialize, Serialize)]
285−#[serde(rename_all = "camelCase")]
286−struct ValueFormat {
287− hex: Option<bool>,
288−}
289−
290−#[derive(Debug, PartialEq, Clone, Deserialize, Serialize)]
291−#[serde(rename_all = "camelCase")]
292−struct VariablesArguments {
293− variables_reference: usize,
294− filter: Option<String>,
295− start: Option<usize>,
296− count: Option<usize>,
297− format: Option<ValueFormat>,
298−}
299−
300−#[derive(Debug, PartialEq, Clone, Deserialize, Serialize)]
301−#[serde(rename_all = "camelCase")]
302−pub struct VariablePresentationHint {
303− pub kind: Option<String>,
304− pub attributes: Option<Vec<String>>,
305− pub visibility: Option<String>,
306−}
307−
308−#[derive(Debug, PartialEq, Clone, Deserialize, Serialize)]
309−#[serde(rename_all = "camelCase")]
310−pub struct Variable {
311− pub name: String,
312− pub value: String,
313− #[serde(rename = "type")]
314− pub data_type: Option<String>,
315− pub presentation_hint: Option<VariablePresentationHint>,
316− pub evaluate_name: Option<String>,
317− pub variables_reference: usize,
318− pub named_variables: Option<usize>,
319− pub indexed_variables: Option<usize>,
320− pub memory_reference: Option<String>,
321−}
322−
323−#[derive(Debug, PartialEq, Clone, Deserialize, Serialize)]
324−#[serde(rename_all = "camelCase")]
325−struct VariablesResponseBody {
326− variables: Vec<Variable>,
327−}
328−
329−#[derive(Debug, PartialEq, Clone, Deserialize, Serialize)]
330−#[serde(rename_all = "camelCase")]
331−pub struct OutputEventBody {
332− pub output: String,
333− pub category: Option<String>,
334− pub group: Option<String>,
335− pub line: Option<usize>,
336− pub column: Option<usize>,
337− pub variables_reference: Option<usize>,
338− pub source: Option<Source>,
339− pub data: Option<Value>,
340−}
341−
342−#[derive(Debug, PartialEq, Clone, Deserialize, Serialize)]
343−#[serde(rename_all = "camelCase")]
344−pub struct StoppedEventBody {
345− pub reason: String,
346− pub description: Option<String>,
347− pub thread_id: Option<usize>,
348− pub preserve_focus_hint: Option<bool>,
349− pub text: Option<String>,
350− pub all_threads_stopped: Option<bool>,
351− pub hit_breakpoint_ids: Option<Vec<usize>>,
352−}
353−
354#[derive(Debug)]
33#[derive(Debug)]
355pub struct Client {
34pub struct Client {
356 id: usize,
35 id: usize,
helix-dap/src/lib.rs+3−1
@@ -1,8 +1,10 @@
1mod client;
1mod client;
2mod transport;
2mod transport;
3+mod types;
3
4
4−pub use client::{Breakpoint, Client, OutputEventBody, SourceBreakpoint, StoppedEventBody};
5+pub use client::Client;
5pub use transport::{Event, Payload, Request, Response, Transport};
6pub use transport::{Event, Payload, Request, Response, Transport};
7+pub use types::*;
6
8
7use thiserror::Error;
9use thiserror::Error;
8#[derive(Error, Debug)]
10#[derive(Error, Debug)]
helix-dap/src/types.rsnew file+324
@@ -0,0 +1,324 @@
1+use serde::{Deserialize, Serialize};
2+use serde_json::Value;
3+
4+#[derive(Debug, PartialEq, Clone, Deserialize, Serialize)]
5+#[serde(rename_all = "camelCase")]
6+pub struct ColumnDescriptor {
7+ pub attribute_name: String,
8+ pub label: String,
9+ pub format: Option<String>,
10+ #[serde(rename = "type")]
11+ pub col_type: Option<String>,
12+ pub width: Option<usize>,
13+}
14+
15+#[derive(Debug, PartialEq, Clone, Deserialize, Serialize)]
16+#[serde(rename_all = "camelCase")]
17+pub struct ExceptionBreakpointsFilter {
18+ pub filter: String,
19+ pub label: String,
20+ pub description: Option<String>,
21+ pub default: Option<bool>,
22+ pub supports_condition: Option<bool>,
23+ pub condition_description: Option<String>,
24+}
25+
26+#[derive(Debug, PartialEq, Clone, Deserialize, Serialize)]
27+#[serde(rename_all = "camelCase")]
28+pub struct DebuggerCapabilities {
29+ pub supports_configuration_done_request: Option<bool>,
30+ pub supports_function_breakpoints: Option<bool>,
31+ pub supports_conditional_breakpoints: Option<bool>,
32+ pub supports_hit_conditional_breakpoints: Option<bool>,
33+ pub supports_evaluate_for_hovers: Option<bool>,
34+ pub supports_step_back: Option<bool>,
35+ pub supports_set_variable: Option<bool>,
36+ pub supports_restart_frame: Option<bool>,
37+ pub supports_goto_targets_request: Option<bool>,
38+ pub supports_step_in_targets_request: Option<bool>,
39+ pub supports_completions_request: Option<bool>,
40+ pub supports_modules_request: Option<bool>,
41+ pub supports_restart_request: Option<bool>,
42+ pub supports_exception_options: Option<bool>,
43+ pub supports_value_formatting_options: Option<bool>,
44+ pub supports_exception_info_request: Option<bool>,
45+ pub support_terminate_debuggee: Option<bool>,
46+ pub support_suspend_debuggee: Option<bool>,
47+ pub supports_delayed_stack_trace_loading: Option<bool>,
48+ pub supports_loaded_sources_request: Option<bool>,
49+ pub supports_log_points: Option<bool>,
50+ pub supports_terminate_threads_request: Option<bool>,
51+ pub supports_set_expression: Option<bool>,
52+ pub supports_terminate_request: Option<bool>,
53+ pub supports_data_breakpoints: Option<bool>,
54+ pub supports_read_memory_request: Option<bool>,
55+ pub supports_write_memory_request: Option<bool>,
56+ pub supports_disassemble_request: Option<bool>,
57+ pub supports_cancel_request: Option<bool>,
58+ pub supports_breakpoint_locations_request: Option<bool>,
59+ pub supports_clipboard_context: Option<bool>,
60+ pub supports_stepping_granularity: Option<bool>,
61+ pub supports_instruction_breakpoints: Option<bool>,
62+ pub supports_exception_filter_options: Option<bool>,
63+ pub exception_breakpoint_filters: Option<Vec<ExceptionBreakpointsFilter>>,
64+ pub completion_trigger_characters: Option<Vec<String>>,
65+ pub additional_module_columns: Option<Vec<ColumnDescriptor>>,
66+ pub supported_checksum_algorithms: Option<Vec<String>>,
67+}
68+
69+impl std::ops::Deref for DebuggerCapabilities {
70+ type Target = Option<bool>;
71+
72+ fn deref(&self) -> &Self::Target {
73+ &self.supports_exception_options
74+ }
75+}
76+
77+#[derive(Debug, PartialEq, Clone, Deserialize, Serialize)]
78+#[serde(rename_all = "camelCase")]
79+pub struct InitializeArguments {
80+ #[serde(rename = "clientID")]
81+ pub client_id: Option<String>,
82+ pub client_name: Option<String>,
83+ #[serde(rename = "adapterID")]
84+ pub adapter_id: String,
85+ pub locale: Option<String>,
86+ #[serde(rename = "linesStartAt1")]
87+ pub lines_start_at_one: Option<bool>,
88+ #[serde(rename = "columnsStartAt1")]
89+ pub columns_start_at_one: Option<bool>,
90+ pub path_format: Option<String>,
91+ pub supports_variable_type: Option<bool>,
92+ pub supports_variable_paging: Option<bool>,
93+ pub supports_run_in_terminal_request: Option<bool>,
94+ pub supports_memory_references: Option<bool>,
95+ pub supports_progress_reporting: Option<bool>,
96+ pub supports_invalidated_event: Option<bool>,
97+}
98+
99+#[derive(Debug, PartialEq, Clone, Deserialize, Serialize)]
100+#[serde(rename_all = "camelCase")]
101+pub struct Checksum {
102+ pub algorithm: String,
103+ pub checksum: String,
104+}
105+
106+#[derive(Debug, PartialEq, Clone, Deserialize, Serialize)]
107+#[serde(rename_all = "camelCase")]
108+pub struct Source {
109+ pub name: Option<String>,
110+ pub path: Option<String>,
111+ pub source_reference: Option<usize>,
112+ pub presentation_hint: Option<String>,
113+ pub origin: Option<String>,
114+ pub sources: Option<Vec<Source>>,
115+ pub adapter_data: Option<Value>,
116+ pub checksums: Option<Vec<Checksum>>,
117+}
118+
119+#[derive(Debug, PartialEq, Clone, Deserialize, Serialize)]
120+#[serde(rename_all = "camelCase")]
121+pub struct SourceBreakpoint {
122+ pub line: usize,
123+ pub column: Option<usize>,
124+ pub condition: Option<String>,
125+ pub hit_condition: Option<String>,
126+ pub log_message: Option<String>,
127+}
128+
129+#[derive(Debug, PartialEq, Clone, Deserialize, Serialize)]
130+#[serde(rename_all = "camelCase")]
131+pub struct SetBreakpointsArguments {
132+ pub source: Source,
133+ pub breakpoints: Option<Vec<SourceBreakpoint>>,
134+ // lines is deprecated
135+ pub source_modified: Option<bool>,
136+}
137+
138+#[derive(Debug, PartialEq, Clone, Deserialize, Serialize)]
139+#[serde(rename_all = "camelCase")]
140+pub struct Breakpoint {
141+ pub id: Option<usize>,
142+ pub verified: bool,
143+ pub message: Option<String>,
144+ pub source: Option<Source>,
145+ pub line: Option<usize>,
146+ pub column: Option<usize>,
147+ pub end_line: Option<usize>,
148+ pub end_column: Option<usize>,
149+ pub instruction_reference: Option<String>,
150+ pub offset: Option<usize>,
151+}
152+
153+#[derive(Debug, PartialEq, Clone, Deserialize, Serialize)]
154+#[serde(rename_all = "camelCase")]
155+pub struct SetBreakpointsResponseBody {
156+ pub breakpoints: Option<Vec<Breakpoint>>,
157+}
158+
159+#[derive(Debug, PartialEq, Clone, Deserialize, Serialize)]
160+#[serde(rename_all = "camelCase")]
161+pub struct ContinueArguments {
162+ pub thread_id: usize,
163+}
164+
165+#[derive(Debug, PartialEq, Clone, Deserialize, Serialize)]
166+#[serde(rename_all = "camelCase")]
167+pub struct ContinueResponseBody {
168+ pub all_threads_continued: Option<bool>,
169+}
170+
171+#[derive(Debug, PartialEq, Clone, Deserialize, Serialize)]
172+#[serde(rename_all = "camelCase")]
173+pub struct StackFrameFormat {
174+ pub parameters: Option<bool>,
175+ pub parameter_types: Option<bool>,
176+ pub parameter_names: Option<bool>,
177+ pub parameter_values: Option<bool>,
178+ pub line: Option<bool>,
179+ pub module: Option<bool>,
180+ pub include_all: Option<bool>,
181+}
182+
183+#[derive(Debug, PartialEq, Clone, Deserialize, Serialize)]
184+#[serde(rename_all = "camelCase")]
185+pub struct StackTraceArguments {
186+ pub thread_id: usize,
187+ pub start_frame: Option<usize>,
188+ pub levels: Option<usize>,
189+ pub format: Option<StackFrameFormat>,
190+}
191+
192+#[derive(Debug, PartialEq, Clone, Deserialize, Serialize)]
193+#[serde(rename_all = "camelCase")]
194+pub struct StackFrame {
195+ pub id: usize,
196+ pub name: String,
197+ pub source: Option<Source>,
198+ pub line: usize,
199+ pub column: usize,
200+ pub end_line: Option<usize>,
201+ pub end_column: Option<usize>,
202+ pub can_restart: Option<bool>,
203+ pub instruction_pointer_reference: Option<String>,
204+ pub module_id: Option<Value>,
205+ pub presentation_hint: Option<String>,
206+}
207+
208+#[derive(Debug, PartialEq, Clone, Deserialize, Serialize)]
209+#[serde(rename_all = "camelCase")]
210+pub struct StackTraceResponseBody {
211+ pub total_frames: Option<usize>,
212+ pub stack_frames: Vec<StackFrame>,
213+}
214+
215+#[derive(Debug, PartialEq, Clone, Deserialize, Serialize)]
216+#[serde(rename_all = "camelCase")]
217+pub struct Thread {
218+ pub id: usize,
219+ pub name: String,
220+}
221+
222+#[derive(Debug, PartialEq, Clone, Deserialize, Serialize)]
223+#[serde(rename_all = "camelCase")]
224+pub struct ThreadsResponseBody {
225+ pub threads: Vec<Thread>,
226+}
227+
228+#[derive(Debug, PartialEq, Clone, Deserialize, Serialize)]
229+#[serde(rename_all = "camelCase")]
230+pub struct ScopesArguments {
231+ pub frame_id: usize,
232+}
233+
234+#[derive(Debug, PartialEq, Clone, Deserialize, Serialize)]
235+#[serde(rename_all = "camelCase")]
236+pub struct Scope {
237+ pub name: String,
238+ pub presentation_hint: Option<String>,
239+ pub variables_reference: usize,
240+ pub named_variables: Option<usize>,
241+ pub indexed_variables: Option<usize>,
242+ pub expensive: bool,
243+ pub source: Option<Source>,
244+ pub line: Option<usize>,
245+ pub column: Option<usize>,
246+ pub end_line: Option<usize>,
247+ pub end_column: Option<usize>,
248+}
249+
250+#[derive(Debug, PartialEq, Clone, Deserialize, Serialize)]
251+#[serde(rename_all = "camelCase")]
252+pub struct ScopesResponseBody {
253+ pub scopes: Vec<Scope>,
254+}
255+
256+#[derive(Debug, PartialEq, Clone, Deserialize, Serialize)]
257+#[serde(rename_all = "camelCase")]
258+pub struct ValueFormat {
259+ pub hex: Option<bool>,
260+}
261+
262+#[derive(Debug, PartialEq, Clone, Deserialize, Serialize)]
263+#[serde(rename_all = "camelCase")]
264+pub struct VariablesArguments {
265+ pub variables_reference: usize,
266+ pub filter: Option<String>,
267+ pub start: Option<usize>,
268+ pub count: Option<usize>,
269+ pub format: Option<ValueFormat>,
270+}
271+
272+#[derive(Debug, PartialEq, Clone, Deserialize, Serialize)]
273+#[serde(rename_all = "camelCase")]
274+pub struct VariablePresentationHint {
275+ pub kind: Option<String>,
276+ pub attributes: Option<Vec<String>>,
277+ pub visibility: Option<String>,
278+}
279+
280+#[derive(Debug, PartialEq, Clone, Deserialize, Serialize)]
281+#[serde(rename_all = "camelCase")]
282+pub struct Variable {
283+ pub name: String,
284+ pub value: String,
285+ #[serde(rename = "type")]
286+ pub data_type: Option<String>,
287+ pub presentation_hint: Option<VariablePresentationHint>,
288+ pub evaluate_name: Option<String>,
289+ pub variables_reference: usize,
290+ pub named_variables: Option<usize>,
291+ pub indexed_variables: Option<usize>,
292+ pub memory_reference: Option<String>,
293+}
294+
295+#[derive(Debug, PartialEq, Clone, Deserialize, Serialize)]
296+#[serde(rename_all = "camelCase")]
297+pub struct VariablesResponseBody {
298+ pub variables: Vec<Variable>,
299+}
300+
301+#[derive(Debug, PartialEq, Clone, Deserialize, Serialize)]
302+#[serde(rename_all = "camelCase")]
303+pub struct OutputEventBody {
304+ pub output: String,
305+ pub category: Option<String>,
306+ pub group: Option<String>,
307+ pub line: Option<usize>,
308+ pub column: Option<usize>,
309+ pub variables_reference: Option<usize>,
310+ pub source: Option<Source>,
311+ pub data: Option<Value>,
312+}
313+
314+#[derive(Debug, PartialEq, Clone, Deserialize, Serialize)]
315+#[serde(rename_all = "camelCase")]
316+pub struct StoppedEventBody {
317+ pub reason: String,
318+ pub description: Option<String>,
319+ pub thread_id: Option<usize>,
320+ pub preserve_focus_hint: Option<bool>,
321+ pub text: Option<String>,
322+ pub all_threads_stopped: Option<bool>,
323+ pub hit_breakpoint_ids: Option<Vec<usize>>,
324+}