1#![allow(non_snake_case, non_camel_case_types)]
2
3use std::os::raw::c_uint;
4use std::mem;
5use crate::sys::r#type::jvmtiCapabilities;
6use crate::sys::utils::BitfieldUnit;
7
8impl jvmtiCapabilities {
9 #[inline]
10 pub fn can_tag_objects(&self) -> c_uint {
11 unsafe { mem::transmute(self._bitfield_1.get(0usize, 1u8) as u32) }
12 }
13
14 #[inline]
15 pub fn set_can_tag_objects(&mut self, val: c_uint) {
16 unsafe {
17 let val: u32 = mem::transmute(val);
18 self._bitfield_1.set(0usize, 1u8, val as u64)
19 }
20 }
21
22 #[inline]
23 pub fn can_generate_field_modification_events(&self) -> c_uint {
24 unsafe { mem::transmute(self._bitfield_1.get(1usize, 1u8) as u32) }
25 }
26
27 #[inline]
28 pub fn set_can_generate_field_modification_events(&mut self, val: c_uint) {
29 unsafe {
30 let val: u32 = mem::transmute(val);
31 self._bitfield_1.set(1usize, 1u8, val as u64)
32 }
33 }
34
35 #[inline]
36 pub fn can_generate_field_access_events(&self) -> c_uint {
37 unsafe { mem::transmute(self._bitfield_1.get(2usize, 1u8) as u32) }
38 }
39
40 #[inline]
41 pub fn set_can_generate_field_access_events(&mut self, val: c_uint) {
42 unsafe {
43 let val: u32 = mem::transmute(val);
44 self._bitfield_1.set(2usize, 1u8, val as u64)
45 }
46 }
47
48 #[inline]
49 pub fn can_get_bytecodes(&self) -> c_uint {
50 unsafe { mem::transmute(self._bitfield_1.get(3usize, 1u8) as u32) }
51 }
52
53 #[inline]
54 pub fn set_can_get_bytecodes(&mut self, val: c_uint) {
55 unsafe {
56 let val: u32 = mem::transmute(val);
57 self._bitfield_1.set(3usize, 1u8, val as u64)
58 }
59 }
60
61 #[inline]
62 pub fn can_get_synthetic_attribute(&self) -> c_uint {
63 unsafe { mem::transmute(self._bitfield_1.get(4usize, 1u8) as u32) }
64 }
65
66 #[inline]
67 pub fn set_can_get_synthetic_attribute(&mut self, val: c_uint) {
68 unsafe {
69 let val: u32 = mem::transmute(val);
70 self._bitfield_1.set(4usize, 1u8, val as u64)
71 }
72 }
73
74 #[inline]
75 pub fn can_get_owned_monitor_info(&self) -> c_uint {
76 unsafe { mem::transmute(self._bitfield_1.get(5usize, 1u8) as u32) }
77 }
78
79 #[inline]
80 pub fn set_can_get_owned_monitor_info(&mut self, val: c_uint) {
81 unsafe {
82 let val: u32 = mem::transmute(val);
83 self._bitfield_1.set(5usize, 1u8, val as u64)
84 }
85 }
86
87 #[inline]
88 pub fn can_get_current_contended_monitor(&self) -> c_uint {
89 unsafe { mem::transmute(self._bitfield_1.get(6usize, 1u8) as u32) }
90 }
91
92 #[inline]
93 pub fn set_can_get_current_contended_monitor(&mut self, val: c_uint) {
94 unsafe {
95 let val: u32 = mem::transmute(val);
96 self._bitfield_1.set(6usize, 1u8, val as u64)
97 }
98 }
99
100 #[inline]
101 pub fn can_get_monitor_info(&self) -> c_uint {
102 unsafe { mem::transmute(self._bitfield_1.get(7usize, 1u8) as u32) }
103 }
104
105 #[inline]
106 pub fn set_can_get_monitor_info(&mut self, val: c_uint) {
107 unsafe {
108 let val: u32 = mem::transmute(val);
109 self._bitfield_1.set(7usize, 1u8, val as u64)
110 }
111 }
112
113 #[inline]
114 pub fn can_pop_frame(&self) -> c_uint {
115 unsafe { mem::transmute(self._bitfield_1.get(8usize, 1u8) as u32) }
116 }
117
118 #[inline]
119 pub fn set_can_pop_frame(&mut self, val: c_uint) {
120 unsafe {
121 let val: u32 = mem::transmute(val);
122 self._bitfield_1.set(8usize, 1u8, val as u64)
123 }
124 }
125
126 #[inline]
127 pub fn can_redefine_classes(&self) -> c_uint {
128 unsafe { mem::transmute(self._bitfield_1.get(9usize, 1u8) as u32) }
129 }
130
131 #[inline]
132 pub fn set_can_redefine_classes(&mut self, val: c_uint) {
133 unsafe {
134 let val: u32 = mem::transmute(val);
135 self._bitfield_1.set(9usize, 1u8, val as u64)
136 }
137 }
138
139 #[inline]
140 pub fn can_signal_thread(&self) -> c_uint {
141 unsafe { mem::transmute(self._bitfield_1.get(10usize, 1u8) as u32) }
142 }
143
144 #[inline]
145 pub fn set_can_signal_thread(&mut self, val: c_uint) {
146 unsafe {
147 let val: u32 = mem::transmute(val);
148 self._bitfield_1.set(10usize, 1u8, val as u64)
149 }
150 }
151
152 #[inline]
153 pub fn can_get_source_file_name(&self) -> c_uint {
154 unsafe { mem::transmute(self._bitfield_1.get(11usize, 1u8) as u32) }
155 }
156
157 #[inline]
158 pub fn set_can_get_source_file_name(&mut self, val: c_uint) {
159 unsafe {
160 let val: u32 = mem::transmute(val);
161 self._bitfield_1.set(11usize, 1u8, val as u64)
162 }
163 }
164
165 #[inline]
166 pub fn can_get_line_numbers(&self) -> c_uint {
167 unsafe { mem::transmute(self._bitfield_1.get(12usize, 1u8) as u32) }
168 }
169
170 #[inline]
171 pub fn set_can_get_line_numbers(&mut self, val: c_uint) {
172 unsafe {
173 let val: u32 = mem::transmute(val);
174 self._bitfield_1.set(12usize, 1u8, val as u64)
175 }
176 }
177
178 #[inline]
179 pub fn can_get_source_debug_extension(&self) -> c_uint {
180 unsafe { mem::transmute(self._bitfield_1.get(13usize, 1u8) as u32) }
181 }
182
183 #[inline]
184 pub fn set_can_get_source_debug_extension(&mut self, val: c_uint) {
185 unsafe {
186 let val: u32 = mem::transmute(val);
187 self._bitfield_1.set(13usize, 1u8, val as u64)
188 }
189 }
190
191 #[inline]
192 pub fn can_access_local_variables(&self) -> c_uint {
193 unsafe { mem::transmute(self._bitfield_1.get(14usize, 1u8) as u32) }
194 }
195
196 #[inline]
197 pub fn set_can_access_local_variables(&mut self, val: c_uint) {
198 unsafe {
199 let val: u32 = mem::transmute(val);
200 self._bitfield_1.set(14usize, 1u8, val as u64)
201 }
202 }
203
204 #[inline]
205 pub fn can_maintain_original_method_order(&self) -> c_uint {
206 unsafe { mem::transmute(self._bitfield_1.get(15usize, 1u8) as u32) }
207 }
208
209 #[inline]
210 pub fn set_can_maintain_original_method_order(&mut self, val: c_uint) {
211 unsafe {
212 let val: u32 = mem::transmute(val);
213 self._bitfield_1.set(15usize, 1u8, val as u64)
214 }
215 }
216
217 #[inline]
218 pub fn can_generate_single_step_events(&self) -> c_uint {
219 unsafe { mem::transmute(self._bitfield_1.get(16usize, 1u8) as u32) }
220 }
221
222 #[inline]
223 pub fn set_can_generate_single_step_events(&mut self, val: c_uint) {
224 unsafe {
225 let val: u32 = mem::transmute(val);
226 self._bitfield_1.set(16usize, 1u8, val as u64)
227 }
228 }
229
230 #[inline]
231 pub fn can_generate_exception_events(&self) -> c_uint {
232 unsafe { mem::transmute(self._bitfield_1.get(17usize, 1u8) as u32) }
233 }
234
235 #[inline]
236 pub fn set_can_generate_exception_events(&mut self, val: c_uint) {
237 unsafe {
238 let val: u32 = mem::transmute(val);
239 self._bitfield_1.set(17usize, 1u8, val as u64)
240 }
241 }
242
243 #[inline]
244 pub fn can_generate_frame_pop_events(&self) -> c_uint {
245 unsafe { mem::transmute(self._bitfield_1.get(18usize, 1u8) as u32) }
246 }
247
248 #[inline]
249 pub fn set_can_generate_frame_pop_events(&mut self, val: c_uint) {
250 unsafe {
251 let val: u32 = mem::transmute(val);
252 self._bitfield_1.set(18usize, 1u8, val as u64)
253 }
254 }
255
256 #[inline]
257 pub fn can_generate_breakpoint_events(&self) -> c_uint {
258 unsafe { mem::transmute(self._bitfield_1.get(19usize, 1u8) as u32) }
259 }
260
261 #[inline]
262 pub fn set_can_generate_breakpoint_events(&mut self, val: c_uint) {
263 unsafe {
264 let val: u32 = mem::transmute(val);
265 self._bitfield_1.set(19usize, 1u8, val as u64)
266 }
267 }
268
269 #[inline]
270 pub fn can_suspend(&self) -> c_uint {
271 unsafe { mem::transmute(self._bitfield_1.get(20usize, 1u8) as u32) }
272 }
273
274 #[inline]
275 pub fn set_can_suspend(&mut self, val: c_uint) {
276 unsafe {
277 let val: u32 = mem::transmute(val);
278 self._bitfield_1.set(20usize, 1u8, val as u64)
279 }
280 }
281
282 #[inline]
283 pub fn can_redefine_any_class(&self) -> c_uint {
284 unsafe { mem::transmute(self._bitfield_1.get(21usize, 1u8) as u32) }
285 }
286
287 #[inline]
288 pub fn set_can_redefine_any_class(&mut self, val: c_uint) {
289 unsafe {
290 let val: u32 = mem::transmute(val);
291 self._bitfield_1.set(21usize, 1u8, val as u64)
292 }
293 }
294
295 #[inline]
296 pub fn can_get_current_thread_cpu_time(&self) -> c_uint {
297 unsafe { mem::transmute(self._bitfield_1.get(22usize, 1u8) as u32) }
298 }
299
300 #[inline]
301 pub fn set_can_get_current_thread_cpu_time(&mut self, val: c_uint) {
302 unsafe {
303 let val: u32 = mem::transmute(val);
304 self._bitfield_1.set(22usize, 1u8, val as u64)
305 }
306 }
307
308 #[inline]
309 pub fn can_get_thread_cpu_time(&self) -> c_uint {
310 unsafe { mem::transmute(self._bitfield_1.get(23usize, 1u8) as u32) }
311 }
312
313 #[inline]
314 pub fn set_can_get_thread_cpu_time(&mut self, val: c_uint) {
315 unsafe {
316 let val: u32 = mem::transmute(val);
317 self._bitfield_1.set(23usize, 1u8, val as u64)
318 }
319 }
320
321 #[inline]
322 pub fn can_generate_method_entry_events(&self) -> c_uint {
323 unsafe { mem::transmute(self._bitfield_1.get(24usize, 1u8) as u32) }
324 }
325
326 #[inline]
327 pub fn set_can_generate_method_entry_events(&mut self, val: c_uint) {
328 unsafe {
329 let val: u32 = mem::transmute(val);
330 self._bitfield_1.set(24usize, 1u8, val as u64)
331 }
332 }
333
334 #[inline]
335 pub fn can_generate_method_exit_events(&self) -> c_uint {
336 unsafe { mem::transmute(self._bitfield_1.get(25usize, 1u8) as u32) }
337 }
338
339 #[inline]
340 pub fn set_can_generate_method_exit_events(&mut self, val: c_uint) {
341 unsafe {
342 let val: u32 = mem::transmute(val);
343 self._bitfield_1.set(25usize, 1u8, val as u64)
344 }
345 }
346
347 #[inline]
348 pub fn can_generate_all_class_hook_events(&self) -> c_uint {
349 unsafe { mem::transmute(self._bitfield_1.get(26usize, 1u8) as u32) }
350 }
351
352 #[inline]
353 pub fn set_can_generate_all_class_hook_events(&mut self, val: c_uint) {
354 unsafe {
355 let val: u32 = mem::transmute(val);
356 self._bitfield_1.set(26usize, 1u8, val as u64)
357 }
358 }
359
360 #[inline]
361 pub fn can_generate_compiled_method_load_events(&self) -> c_uint {
362 unsafe { mem::transmute(self._bitfield_1.get(27usize, 1u8) as u32) }
363 }
364
365 #[inline]
366 pub fn set_can_generate_compiled_method_load_events(&mut self, val: c_uint) {
367 unsafe {
368 let val: u32 = mem::transmute(val);
369 self._bitfield_1.set(27usize, 1u8, val as u64)
370 }
371 }
372
373 #[inline]
374 pub fn can_generate_monitor_events(&self) -> c_uint {
375 unsafe { mem::transmute(self._bitfield_1.get(28usize, 1u8) as u32) }
376 }
377
378 #[inline]
379 pub fn set_can_generate_monitor_events(&mut self, val: c_uint) {
380 unsafe {
381 let val: u32 = mem::transmute(val);
382 self._bitfield_1.set(28usize, 1u8, val as u64)
383 }
384 }
385
386 #[inline]
387 pub fn can_generate_vm_object_alloc_events(&self) -> c_uint {
388 unsafe { mem::transmute(self._bitfield_1.get(29usize, 1u8) as u32) }
389 }
390
391 #[inline]
392 pub fn set_can_generate_vm_object_alloc_events(&mut self, val: c_uint) {
393 unsafe {
394 let val: u32 = mem::transmute(val);
395 self._bitfield_1.set(29usize, 1u8, val as u64)
396 }
397 }
398
399 #[inline]
400 pub fn can_generate_native_method_bind_events(&self) -> c_uint {
401 unsafe { mem::transmute(self._bitfield_1.get(30usize, 1u8) as u32) }
402 }
403
404 #[inline]
405 pub fn set_can_generate_native_method_bind_events(&mut self, val: c_uint) {
406 unsafe {
407 let val: u32 = mem::transmute(val);
408 self._bitfield_1.set(30usize, 1u8, val as u64)
409 }
410 }
411
412 #[inline]
413 pub fn can_generate_garbage_collection_events(&self) -> c_uint {
414 unsafe { mem::transmute(self._bitfield_1.get(31usize, 1u8) as u32) }
415 }
416
417 #[inline]
418 pub fn set_can_generate_garbage_collection_events(&mut self, val: c_uint) {
419 unsafe {
420 let val: u32 = mem::transmute(val);
421 self._bitfield_1.set(31usize, 1u8, val as u64)
422 }
423 }
424
425 #[inline]
426 pub fn can_generate_object_free_events(&self) -> c_uint {
427 unsafe { mem::transmute(self._bitfield_1.get(32usize, 1u8) as u32) }
428 }
429
430 #[inline]
431 pub fn set_can_generate_object_free_events(&mut self, val: c_uint) {
432 unsafe {
433 let val: u32 = mem::transmute(val);
434 self._bitfield_1.set(32usize, 1u8, val as u64)
435 }
436 }
437
438 #[inline]
439 pub fn can_force_early_return(&self) -> c_uint {
440 unsafe { mem::transmute(self._bitfield_1.get(33usize, 1u8) as u32) }
441 }
442
443 #[inline]
444 pub fn set_can_force_early_return(&mut self, val: c_uint) {
445 unsafe {
446 let val: u32 = mem::transmute(val);
447 self._bitfield_1.set(33usize, 1u8, val as u64)
448 }
449 }
450
451 #[inline]
452 pub fn can_get_owned_monitor_stack_depth_info(&self) -> c_uint {
453 unsafe { mem::transmute(self._bitfield_1.get(34usize, 1u8) as u32) }
454 }
455
456 #[inline]
457 pub fn set_can_get_owned_monitor_stack_depth_info(&mut self, val: c_uint) {
458 unsafe {
459 let val: u32 = mem::transmute(val);
460 self._bitfield_1.set(34usize, 1u8, val as u64)
461 }
462 }
463
464 #[inline]
465 pub fn can_get_constant_pool(&self) -> c_uint {
466 unsafe { mem::transmute(self._bitfield_1.get(35usize, 1u8) as u32) }
467 }
468
469 #[inline]
470 pub fn set_can_get_constant_pool(&mut self, val: c_uint) {
471 unsafe {
472 let val: u32 = mem::transmute(val);
473 self._bitfield_1.set(35usize, 1u8, val as u64)
474 }
475 }
476
477 #[inline]
478 pub fn can_set_native_method_prefix(&self) -> c_uint {
479 unsafe { mem::transmute(self._bitfield_1.get(36usize, 1u8) as u32) }
480 }
481
482 #[inline]
483 pub fn set_can_set_native_method_prefix(&mut self, val: c_uint) {
484 unsafe {
485 let val: u32 = mem::transmute(val);
486 self._bitfield_1.set(36usize, 1u8, val as u64)
487 }
488 }
489
490 #[inline]
491 pub fn can_retransform_classes(&self) -> c_uint {
492 unsafe { mem::transmute(self._bitfield_1.get(37usize, 1u8) as u32) }
493 }
494
495 #[inline]
496 pub fn set_can_retransform_classes(&mut self, val: c_uint) {
497 unsafe {
498 let val: u32 = mem::transmute(val);
499 self._bitfield_1.set(37usize, 1u8, val as u64)
500 }
501 }
502
503 #[inline]
504 pub fn can_retransform_any_class(&self) -> c_uint {
505 unsafe { mem::transmute(self._bitfield_1.get(38usize, 1u8) as u32) }
506 }
507
508 #[inline]
509 pub fn set_can_retransform_any_class(&mut self, val: c_uint) {
510 unsafe {
511 let val: u32 = mem::transmute(val);
512 self._bitfield_1.set(38usize, 1u8, val as u64)
513 }
514 }
515
516 #[inline]
517 pub fn can_generate_resource_exhaustion_heap_events(&self) -> c_uint {
518 unsafe { mem::transmute(self._bitfield_1.get(39usize, 1u8) as u32) }
519 }
520
521 #[inline]
522 pub fn set_can_generate_resource_exhaustion_heap_events(
523 &mut self,
524 val: c_uint,
525 ) {
526 unsafe {
527 let val: u32 = mem::transmute(val);
528 self._bitfield_1.set(39usize, 1u8, val as u64)
529 }
530 }
531
532 #[inline]
533 pub fn can_generate_resource_exhaustion_threads_events(&self) -> c_uint {
534 unsafe { mem::transmute(self._bitfield_1.get(40usize, 1u8) as u32) }
535 }
536
537 #[inline]
538 pub fn set_can_generate_resource_exhaustion_threads_events(
539 &mut self,
540 val: c_uint,
541 ) {
542 unsafe {
543 let val: u32 = mem::transmute(val);
544 self._bitfield_1.set(40usize, 1u8, val as u64)
545 }
546 }
547
548 #[inline]
549 pub fn newBitfield(
550 can_tag_objects: c_uint,
551 can_generate_field_modification_events: c_uint,
552 can_generate_field_access_events: c_uint,
553 can_get_bytecodes: c_uint,
554 can_get_synthetic_attribute: c_uint,
555 can_get_owned_monitor_info: c_uint,
556 can_get_current_contended_monitor: c_uint,
557 can_get_monitor_info: c_uint,
558 can_pop_frame: c_uint,
559 can_redefine_classes: c_uint,
560 can_signal_thread: c_uint,
561 can_get_source_file_name: c_uint,
562 can_get_line_numbers: c_uint,
563 can_get_source_debug_extension: c_uint,
564 can_access_local_variables: c_uint,
565 can_maintain_original_method_order: c_uint,
566 can_generate_single_step_events: c_uint,
567 can_generate_exception_events: c_uint,
568 can_generate_frame_pop_events: c_uint,
569 can_generate_breakpoint_events: c_uint,
570 can_suspend: c_uint,
571 can_redefine_any_class: c_uint,
572 can_get_current_thread_cpu_time: c_uint,
573 can_get_thread_cpu_time: c_uint,
574 can_generate_method_entry_events: c_uint,
575 can_generate_method_exit_events: c_uint,
576 can_generate_all_class_hook_events: c_uint,
577 can_generate_compiled_method_load_events: c_uint,
578 can_generate_monitor_events: c_uint,
579 can_generate_vm_object_alloc_events: c_uint,
580 can_generate_native_method_bind_events: c_uint,
581 can_generate_garbage_collection_events: c_uint,
582 can_generate_object_free_events: c_uint,
583 can_force_early_return: c_uint,
584 can_get_owned_monitor_stack_depth_info: c_uint,
585 can_get_constant_pool: c_uint,
586 can_set_native_method_prefix: c_uint,
587 can_retransform_classes: c_uint,
588 can_retransform_any_class: c_uint,
589 can_generate_resource_exhaustion_heap_events: c_uint,
590 can_generate_resource_exhaustion_threads_events: c_uint,
591 ) -> BitfieldUnit<[u8; 16usize], u8> {
592 let mut unit: BitfieldUnit<[u8; 16usize], u8> =
593 Default::default();
594 unit.set(0usize, 1u8, {
595 let can_tag_objects: u32 = unsafe { mem::transmute(can_tag_objects) };
596 can_tag_objects as u64
597 });
598 unit.set(1usize, 1u8, {
599 let can_generate_field_modification_events: u32 =
600 unsafe { mem::transmute(can_generate_field_modification_events) };
601 can_generate_field_modification_events as u64
602 });
603 unit.set(2usize, 1u8, {
604 let can_generate_field_access_events: u32 =
605 unsafe { mem::transmute(can_generate_field_access_events) };
606 can_generate_field_access_events as u64
607 });
608 unit.set(3usize, 1u8, {
609 let can_get_bytecodes: u32 = unsafe { mem::transmute(can_get_bytecodes) };
610 can_get_bytecodes as u64
611 });
612 unit.set(4usize, 1u8, {
613 let can_get_synthetic_attribute: u32 =
614 unsafe { mem::transmute(can_get_synthetic_attribute) };
615 can_get_synthetic_attribute as u64
616 });
617 unit.set(5usize, 1u8, {
618 let can_get_owned_monitor_info: u32 =
619 unsafe { mem::transmute(can_get_owned_monitor_info) };
620 can_get_owned_monitor_info as u64
621 });
622 unit.set(6usize, 1u8, {
623 let can_get_current_contended_monitor: u32 =
624 unsafe { mem::transmute(can_get_current_contended_monitor) };
625 can_get_current_contended_monitor as u64
626 });
627 unit.set(7usize, 1u8, {
628 let can_get_monitor_info: u32 = unsafe { mem::transmute(can_get_monitor_info) };
629 can_get_monitor_info as u64
630 });
631 unit.set(8usize, 1u8, {
632 let can_pop_frame: u32 = unsafe { mem::transmute(can_pop_frame) };
633 can_pop_frame as u64
634 });
635 unit.set(9usize, 1u8, {
636 let can_redefine_classes: u32 = unsafe { mem::transmute(can_redefine_classes) };
637 can_redefine_classes as u64
638 });
639 unit.set(10usize, 1u8, {
640 let can_signal_thread: u32 = unsafe { mem::transmute(can_signal_thread) };
641 can_signal_thread as u64
642 });
643 unit.set(11usize, 1u8, {
644 let can_get_source_file_name: u32 =
645 unsafe { mem::transmute(can_get_source_file_name) };
646 can_get_source_file_name as u64
647 });
648 unit.set(12usize, 1u8, {
649 let can_get_line_numbers: u32 = unsafe { mem::transmute(can_get_line_numbers) };
650 can_get_line_numbers as u64
651 });
652 unit.set(13usize, 1u8, {
653 let can_get_source_debug_extension: u32 =
654 unsafe { mem::transmute(can_get_source_debug_extension) };
655 can_get_source_debug_extension as u64
656 });
657 unit.set(14usize, 1u8, {
658 let can_access_local_variables: u32 =
659 unsafe { mem::transmute(can_access_local_variables) };
660 can_access_local_variables as u64
661 });
662 unit.set(15usize, 1u8, {
663 let can_maintain_original_method_order: u32 =
664 unsafe { mem::transmute(can_maintain_original_method_order) };
665 can_maintain_original_method_order as u64
666 });
667 unit.set(16usize, 1u8, {
668 let can_generate_single_step_events: u32 =
669 unsafe { mem::transmute(can_generate_single_step_events) };
670 can_generate_single_step_events as u64
671 });
672 unit.set(17usize, 1u8, {
673 let can_generate_exception_events: u32 =
674 unsafe { mem::transmute(can_generate_exception_events) };
675 can_generate_exception_events as u64
676 });
677 unit.set(18usize, 1u8, {
678 let can_generate_frame_pop_events: u32 =
679 unsafe { mem::transmute(can_generate_frame_pop_events) };
680 can_generate_frame_pop_events as u64
681 });
682 unit.set(19usize, 1u8, {
683 let can_generate_breakpoint_events: u32 =
684 unsafe { mem::transmute(can_generate_breakpoint_events) };
685 can_generate_breakpoint_events as u64
686 });
687 unit.set(20usize, 1u8, {
688 let can_suspend: u32 = unsafe { mem::transmute(can_suspend) };
689 can_suspend as u64
690 });
691 unit.set(21usize, 1u8, {
692 let can_redefine_any_class: u32 =
693 unsafe { mem::transmute(can_redefine_any_class) };
694 can_redefine_any_class as u64
695 });
696 unit.set(22usize, 1u8, {
697 let can_get_current_thread_cpu_time: u32 =
698 unsafe { mem::transmute(can_get_current_thread_cpu_time) };
699 can_get_current_thread_cpu_time as u64
700 });
701 unit.set(23usize, 1u8, {
702 let can_get_thread_cpu_time: u32 =
703 unsafe { mem::transmute(can_get_thread_cpu_time) };
704 can_get_thread_cpu_time as u64
705 });
706 unit.set(24usize, 1u8, {
707 let can_generate_method_entry_events: u32 =
708 unsafe { mem::transmute(can_generate_method_entry_events) };
709 can_generate_method_entry_events as u64
710 });
711 unit.set(25usize, 1u8, {
712 let can_generate_method_exit_events: u32 =
713 unsafe { mem::transmute(can_generate_method_exit_events) };
714 can_generate_method_exit_events as u64
715 });
716 unit.set(26usize, 1u8, {
717 let can_generate_all_class_hook_events: u32 =
718 unsafe { mem::transmute(can_generate_all_class_hook_events) };
719 can_generate_all_class_hook_events as u64
720 });
721 unit.set(27usize, 1u8, {
722 let can_generate_compiled_method_load_events: u32 =
723 unsafe { mem::transmute(can_generate_compiled_method_load_events) };
724 can_generate_compiled_method_load_events as u64
725 });
726 unit.set(28usize, 1u8, {
727 let can_generate_monitor_events: u32 =
728 unsafe { mem::transmute(can_generate_monitor_events) };
729 can_generate_monitor_events as u64
730 });
731 unit.set(29usize, 1u8, {
732 let can_generate_vm_object_alloc_events: u32 =
733 unsafe { mem::transmute(can_generate_vm_object_alloc_events) };
734 can_generate_vm_object_alloc_events as u64
735 });
736 unit.set(30usize, 1u8, {
737 let can_generate_native_method_bind_events: u32 =
738 unsafe { mem::transmute(can_generate_native_method_bind_events) };
739 can_generate_native_method_bind_events as u64
740 });
741 unit.set(31usize, 1u8, {
742 let can_generate_garbage_collection_events: u32 =
743 unsafe { mem::transmute(can_generate_garbage_collection_events) };
744 can_generate_garbage_collection_events as u64
745 });
746 unit.set(32usize, 1u8, {
747 let can_generate_object_free_events: u32 =
748 unsafe { mem::transmute(can_generate_object_free_events) };
749 can_generate_object_free_events as u64
750 });
751 unit.set(33usize, 1u8, {
752 let can_force_early_return: u32 =
753 unsafe { mem::transmute(can_force_early_return) };
754 can_force_early_return as u64
755 });
756 unit.set(34usize, 1u8, {
757 let can_get_owned_monitor_stack_depth_info: u32 =
758 unsafe { mem::transmute(can_get_owned_monitor_stack_depth_info) };
759 can_get_owned_monitor_stack_depth_info as u64
760 });
761 unit.set(35usize, 1u8, {
762 let can_get_constant_pool: u32 =
763 unsafe { mem::transmute(can_get_constant_pool) };
764 can_get_constant_pool as u64
765 });
766 unit.set(36usize, 1u8, {
767 let can_set_native_method_prefix: u32 =
768 unsafe { mem::transmute(can_set_native_method_prefix) };
769 can_set_native_method_prefix as u64
770 });
771 unit.set(37usize, 1u8, {
772 let can_retransform_classes: u32 =
773 unsafe { mem::transmute(can_retransform_classes) };
774 can_retransform_classes as u64
775 });
776 unit.set(38usize, 1u8, {
777 let can_retransform_any_class: u32 =
778 unsafe { mem::transmute(can_retransform_any_class) };
779 can_retransform_any_class as u64
780 });
781 unit.set(39usize, 1u8, {
782 let can_generate_resource_exhaustion_heap_events: u32 =
783 unsafe { mem::transmute(can_generate_resource_exhaustion_heap_events) };
784 can_generate_resource_exhaustion_heap_events as u64
785 });
786 unit.set(40usize, 1u8, {
787 let can_generate_resource_exhaustion_threads_events: u32 =
788 unsafe { mem::transmute(can_generate_resource_exhaustion_threads_events) };
789 can_generate_resource_exhaustion_threads_events as u64
790 });
791
792 unit
793 }
794
795 #[inline]
796 pub fn newEmptyBitfield() -> BitfieldUnit<[u8; 16usize], u8> {
797 jvmtiCapabilities::newBitfield(0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
798 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
799 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
800 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
801 0)
802 }
803}