1pub type size_t = ::std::os::raw::c_ulonglong;
4pub type ULONG = ::std::os::raw::c_ulong;
5pub type PULONG = *mut ULONG;
6pub type USHORT = ::std::os::raw::c_ushort;
7pub type UCHAR = ::std::os::raw::c_uchar;
8pub type DWORD = ::std::os::raw::c_ulong;
9pub type BOOL = ::std::os::raw::c_int;
10pub type BYTE = ::std::os::raw::c_uchar;
11pub type WORD = ::std::os::raw::c_ushort;
12pub type LPVOID = *mut ::std::os::raw::c_void;
13pub type INT_PTR = ::std::os::raw::c_longlong;
14pub type ULONG_PTR = ::std::os::raw::c_ulonglong;
15pub type DWORD64 = ::std::os::raw::c_ulonglong;
16pub type PVOID = *mut ::std::os::raw::c_void;
17pub type SHORT = ::std::os::raw::c_short;
18pub type LONG = ::std::os::raw::c_long;
19pub type HANDLE = *mut ::std::os::raw::c_void;
20pub type LONGLONG = ::std::os::raw::c_longlong;
21pub type ULONGLONG = ::std::os::raw::c_ulonglong;
22#[repr(C)]
23#[repr(align(16))]
24#[derive(Debug, Copy, Clone)]
25pub struct _M128A {
26 pub Low: ULONGLONG,
27 pub High: LONGLONG,
28}
29#[test]
30fn bindgen_test_layout__M128A() {
31 assert_eq!(
32 ::std::mem::size_of::<_M128A>(),
33 16usize,
34 concat!("Size of: ", stringify!(_M128A))
35 );
36 assert_eq!(
37 ::std::mem::align_of::<_M128A>(),
38 16usize,
39 concat!("Alignment of ", stringify!(_M128A))
40 );
41 assert_eq!(
42 unsafe { &(*(::std::ptr::null::<_M128A>())).Low as *const _ as usize },
43 0usize,
44 concat!(
45 "Offset of field: ",
46 stringify!(_M128A),
47 "::",
48 stringify!(Low)
49 )
50 );
51 assert_eq!(
52 unsafe { &(*(::std::ptr::null::<_M128A>())).High as *const _ as usize },
53 8usize,
54 concat!(
55 "Offset of field: ",
56 stringify!(_M128A),
57 "::",
58 stringify!(High)
59 )
60 );
61}
62pub type M128A = _M128A;
63#[repr(C)]
64#[repr(align(16))]
65#[derive(Copy, Clone)]
66pub struct _XSAVE_FORMAT {
67 pub ControlWord: WORD,
68 pub StatusWord: WORD,
69 pub TagWord: BYTE,
70 pub Reserved1: BYTE,
71 pub ErrorOpcode: WORD,
72 pub ErrorOffset: DWORD,
73 pub ErrorSelector: WORD,
74 pub Reserved2: WORD,
75 pub DataOffset: DWORD,
76 pub DataSelector: WORD,
77 pub Reserved3: WORD,
78 pub MxCsr: DWORD,
79 pub MxCsr_Mask: DWORD,
80 pub FloatRegisters: [M128A; 8usize],
81 pub XmmRegisters: [M128A; 16usize],
82 pub Reserved4: [BYTE; 96usize],
83}
84#[test]
85fn bindgen_test_layout__XSAVE_FORMAT() {
86 assert_eq!(
87 ::std::mem::size_of::<_XSAVE_FORMAT>(),
88 512usize,
89 concat!("Size of: ", stringify!(_XSAVE_FORMAT))
90 );
91 assert_eq!(
92 ::std::mem::align_of::<_XSAVE_FORMAT>(),
93 16usize,
94 concat!("Alignment of ", stringify!(_XSAVE_FORMAT))
95 );
96 assert_eq!(
97 unsafe { &(*(::std::ptr::null::<_XSAVE_FORMAT>())).ControlWord as *const _ as usize },
98 0usize,
99 concat!(
100 "Offset of field: ",
101 stringify!(_XSAVE_FORMAT),
102 "::",
103 stringify!(ControlWord)
104 )
105 );
106 assert_eq!(
107 unsafe { &(*(::std::ptr::null::<_XSAVE_FORMAT>())).StatusWord as *const _ as usize },
108 2usize,
109 concat!(
110 "Offset of field: ",
111 stringify!(_XSAVE_FORMAT),
112 "::",
113 stringify!(StatusWord)
114 )
115 );
116 assert_eq!(
117 unsafe { &(*(::std::ptr::null::<_XSAVE_FORMAT>())).TagWord as *const _ as usize },
118 4usize,
119 concat!(
120 "Offset of field: ",
121 stringify!(_XSAVE_FORMAT),
122 "::",
123 stringify!(TagWord)
124 )
125 );
126 assert_eq!(
127 unsafe { &(*(::std::ptr::null::<_XSAVE_FORMAT>())).Reserved1 as *const _ as usize },
128 5usize,
129 concat!(
130 "Offset of field: ",
131 stringify!(_XSAVE_FORMAT),
132 "::",
133 stringify!(Reserved1)
134 )
135 );
136 assert_eq!(
137 unsafe { &(*(::std::ptr::null::<_XSAVE_FORMAT>())).ErrorOpcode as *const _ as usize },
138 6usize,
139 concat!(
140 "Offset of field: ",
141 stringify!(_XSAVE_FORMAT),
142 "::",
143 stringify!(ErrorOpcode)
144 )
145 );
146 assert_eq!(
147 unsafe { &(*(::std::ptr::null::<_XSAVE_FORMAT>())).ErrorOffset as *const _ as usize },
148 8usize,
149 concat!(
150 "Offset of field: ",
151 stringify!(_XSAVE_FORMAT),
152 "::",
153 stringify!(ErrorOffset)
154 )
155 );
156 assert_eq!(
157 unsafe { &(*(::std::ptr::null::<_XSAVE_FORMAT>())).ErrorSelector as *const _ as usize },
158 12usize,
159 concat!(
160 "Offset of field: ",
161 stringify!(_XSAVE_FORMAT),
162 "::",
163 stringify!(ErrorSelector)
164 )
165 );
166 assert_eq!(
167 unsafe { &(*(::std::ptr::null::<_XSAVE_FORMAT>())).Reserved2 as *const _ as usize },
168 14usize,
169 concat!(
170 "Offset of field: ",
171 stringify!(_XSAVE_FORMAT),
172 "::",
173 stringify!(Reserved2)
174 )
175 );
176 assert_eq!(
177 unsafe { &(*(::std::ptr::null::<_XSAVE_FORMAT>())).DataOffset as *const _ as usize },
178 16usize,
179 concat!(
180 "Offset of field: ",
181 stringify!(_XSAVE_FORMAT),
182 "::",
183 stringify!(DataOffset)
184 )
185 );
186 assert_eq!(
187 unsafe { &(*(::std::ptr::null::<_XSAVE_FORMAT>())).DataSelector as *const _ as usize },
188 20usize,
189 concat!(
190 "Offset of field: ",
191 stringify!(_XSAVE_FORMAT),
192 "::",
193 stringify!(DataSelector)
194 )
195 );
196 assert_eq!(
197 unsafe { &(*(::std::ptr::null::<_XSAVE_FORMAT>())).Reserved3 as *const _ as usize },
198 22usize,
199 concat!(
200 "Offset of field: ",
201 stringify!(_XSAVE_FORMAT),
202 "::",
203 stringify!(Reserved3)
204 )
205 );
206 assert_eq!(
207 unsafe { &(*(::std::ptr::null::<_XSAVE_FORMAT>())).MxCsr as *const _ as usize },
208 24usize,
209 concat!(
210 "Offset of field: ",
211 stringify!(_XSAVE_FORMAT),
212 "::",
213 stringify!(MxCsr)
214 )
215 );
216 assert_eq!(
217 unsafe { &(*(::std::ptr::null::<_XSAVE_FORMAT>())).MxCsr_Mask as *const _ as usize },
218 28usize,
219 concat!(
220 "Offset of field: ",
221 stringify!(_XSAVE_FORMAT),
222 "::",
223 stringify!(MxCsr_Mask)
224 )
225 );
226 assert_eq!(
227 unsafe { &(*(::std::ptr::null::<_XSAVE_FORMAT>())).FloatRegisters as *const _ as usize },
228 32usize,
229 concat!(
230 "Offset of field: ",
231 stringify!(_XSAVE_FORMAT),
232 "::",
233 stringify!(FloatRegisters)
234 )
235 );
236 assert_eq!(
237 unsafe { &(*(::std::ptr::null::<_XSAVE_FORMAT>())).XmmRegisters as *const _ as usize },
238 160usize,
239 concat!(
240 "Offset of field: ",
241 stringify!(_XSAVE_FORMAT),
242 "::",
243 stringify!(XmmRegisters)
244 )
245 );
246 assert_eq!(
247 unsafe { &(*(::std::ptr::null::<_XSAVE_FORMAT>())).Reserved4 as *const _ as usize },
248 416usize,
249 concat!(
250 "Offset of field: ",
251 stringify!(_XSAVE_FORMAT),
252 "::",
253 stringify!(Reserved4)
254 )
255 );
256}
257pub type XSAVE_FORMAT = _XSAVE_FORMAT;
258pub type XMM_SAVE_AREA32 = XSAVE_FORMAT;
259#[repr(C)]
260#[repr(align(16))]
261#[derive(Copy, Clone)]
262pub struct _CONTEXT {
263 pub P1Home: DWORD64,
264 pub P2Home: DWORD64,
265 pub P3Home: DWORD64,
266 pub P4Home: DWORD64,
267 pub P5Home: DWORD64,
268 pub P6Home: DWORD64,
269 pub ContextFlags: DWORD,
270 pub MxCsr: DWORD,
271 pub SegCs: WORD,
272 pub SegDs: WORD,
273 pub SegEs: WORD,
274 pub SegFs: WORD,
275 pub SegGs: WORD,
276 pub SegSs: WORD,
277 pub EFlags: DWORD,
278 pub Dr0: DWORD64,
279 pub Dr1: DWORD64,
280 pub Dr2: DWORD64,
281 pub Dr3: DWORD64,
282 pub Dr6: DWORD64,
283 pub Dr7: DWORD64,
284 pub Rax: DWORD64,
285 pub Rcx: DWORD64,
286 pub Rdx: DWORD64,
287 pub Rbx: DWORD64,
288 pub Rsp: DWORD64,
289 pub Rbp: DWORD64,
290 pub Rsi: DWORD64,
291 pub Rdi: DWORD64,
292 pub R8: DWORD64,
293 pub R9: DWORD64,
294 pub R10: DWORD64,
295 pub R11: DWORD64,
296 pub R12: DWORD64,
297 pub R13: DWORD64,
298 pub R14: DWORD64,
299 pub R15: DWORD64,
300 pub Rip: DWORD64,
301 pub __bindgen_anon_1: _CONTEXT__bindgen_ty_1,
302 pub VectorRegister: [M128A; 26usize],
303 pub VectorControl: DWORD64,
304 pub DebugControl: DWORD64,
305 pub LastBranchToRip: DWORD64,
306 pub LastBranchFromRip: DWORD64,
307 pub LastExceptionToRip: DWORD64,
308 pub LastExceptionFromRip: DWORD64,
309}
310#[repr(C)]
311#[repr(align(16))]
312#[derive(Copy, Clone)]
313pub union _CONTEXT__bindgen_ty_1 {
314 pub FltSave: XMM_SAVE_AREA32,
315 pub __bindgen_anon_1: _CONTEXT__bindgen_ty_1__bindgen_ty_1,
316 _bindgen_union_align: [u128; 32usize],
317}
318#[repr(C)]
319#[repr(align(16))]
320#[derive(Debug, Copy, Clone)]
321pub struct _CONTEXT__bindgen_ty_1__bindgen_ty_1 {
322 pub Header: [M128A; 2usize],
323 pub Legacy: [M128A; 8usize],
324 pub Xmm0: M128A,
325 pub Xmm1: M128A,
326 pub Xmm2: M128A,
327 pub Xmm3: M128A,
328 pub Xmm4: M128A,
329 pub Xmm5: M128A,
330 pub Xmm6: M128A,
331 pub Xmm7: M128A,
332 pub Xmm8: M128A,
333 pub Xmm9: M128A,
334 pub Xmm10: M128A,
335 pub Xmm11: M128A,
336 pub Xmm12: M128A,
337 pub Xmm13: M128A,
338 pub Xmm14: M128A,
339 pub Xmm15: M128A,
340}
341#[test]
342fn bindgen_test_layout__CONTEXT__bindgen_ty_1__bindgen_ty_1() {
343 assert_eq!(
344 ::std::mem::size_of::<_CONTEXT__bindgen_ty_1__bindgen_ty_1>(),
345 416usize,
346 concat!(
347 "Size of: ",
348 stringify!(_CONTEXT__bindgen_ty_1__bindgen_ty_1)
349 )
350 );
351 assert_eq!(
352 ::std::mem::align_of::<_CONTEXT__bindgen_ty_1__bindgen_ty_1>(),
353 16usize,
354 concat!(
355 "Alignment of ",
356 stringify!(_CONTEXT__bindgen_ty_1__bindgen_ty_1)
357 )
358 );
359 assert_eq!(
360 unsafe {
361 &(*(::std::ptr::null::<_CONTEXT__bindgen_ty_1__bindgen_ty_1>())).Header as *const _
362 as usize
363 },
364 0usize,
365 concat!(
366 "Offset of field: ",
367 stringify!(_CONTEXT__bindgen_ty_1__bindgen_ty_1),
368 "::",
369 stringify!(Header)
370 )
371 );
372 assert_eq!(
373 unsafe {
374 &(*(::std::ptr::null::<_CONTEXT__bindgen_ty_1__bindgen_ty_1>())).Legacy as *const _
375 as usize
376 },
377 32usize,
378 concat!(
379 "Offset of field: ",
380 stringify!(_CONTEXT__bindgen_ty_1__bindgen_ty_1),
381 "::",
382 stringify!(Legacy)
383 )
384 );
385 assert_eq!(
386 unsafe {
387 &(*(::std::ptr::null::<_CONTEXT__bindgen_ty_1__bindgen_ty_1>())).Xmm0 as *const _
388 as usize
389 },
390 160usize,
391 concat!(
392 "Offset of field: ",
393 stringify!(_CONTEXT__bindgen_ty_1__bindgen_ty_1),
394 "::",
395 stringify!(Xmm0)
396 )
397 );
398 assert_eq!(
399 unsafe {
400 &(*(::std::ptr::null::<_CONTEXT__bindgen_ty_1__bindgen_ty_1>())).Xmm1 as *const _
401 as usize
402 },
403 176usize,
404 concat!(
405 "Offset of field: ",
406 stringify!(_CONTEXT__bindgen_ty_1__bindgen_ty_1),
407 "::",
408 stringify!(Xmm1)
409 )
410 );
411 assert_eq!(
412 unsafe {
413 &(*(::std::ptr::null::<_CONTEXT__bindgen_ty_1__bindgen_ty_1>())).Xmm2 as *const _
414 as usize
415 },
416 192usize,
417 concat!(
418 "Offset of field: ",
419 stringify!(_CONTEXT__bindgen_ty_1__bindgen_ty_1),
420 "::",
421 stringify!(Xmm2)
422 )
423 );
424 assert_eq!(
425 unsafe {
426 &(*(::std::ptr::null::<_CONTEXT__bindgen_ty_1__bindgen_ty_1>())).Xmm3 as *const _
427 as usize
428 },
429 208usize,
430 concat!(
431 "Offset of field: ",
432 stringify!(_CONTEXT__bindgen_ty_1__bindgen_ty_1),
433 "::",
434 stringify!(Xmm3)
435 )
436 );
437 assert_eq!(
438 unsafe {
439 &(*(::std::ptr::null::<_CONTEXT__bindgen_ty_1__bindgen_ty_1>())).Xmm4 as *const _
440 as usize
441 },
442 224usize,
443 concat!(
444 "Offset of field: ",
445 stringify!(_CONTEXT__bindgen_ty_1__bindgen_ty_1),
446 "::",
447 stringify!(Xmm4)
448 )
449 );
450 assert_eq!(
451 unsafe {
452 &(*(::std::ptr::null::<_CONTEXT__bindgen_ty_1__bindgen_ty_1>())).Xmm5 as *const _
453 as usize
454 },
455 240usize,
456 concat!(
457 "Offset of field: ",
458 stringify!(_CONTEXT__bindgen_ty_1__bindgen_ty_1),
459 "::",
460 stringify!(Xmm5)
461 )
462 );
463 assert_eq!(
464 unsafe {
465 &(*(::std::ptr::null::<_CONTEXT__bindgen_ty_1__bindgen_ty_1>())).Xmm6 as *const _
466 as usize
467 },
468 256usize,
469 concat!(
470 "Offset of field: ",
471 stringify!(_CONTEXT__bindgen_ty_1__bindgen_ty_1),
472 "::",
473 stringify!(Xmm6)
474 )
475 );
476 assert_eq!(
477 unsafe {
478 &(*(::std::ptr::null::<_CONTEXT__bindgen_ty_1__bindgen_ty_1>())).Xmm7 as *const _
479 as usize
480 },
481 272usize,
482 concat!(
483 "Offset of field: ",
484 stringify!(_CONTEXT__bindgen_ty_1__bindgen_ty_1),
485 "::",
486 stringify!(Xmm7)
487 )
488 );
489 assert_eq!(
490 unsafe {
491 &(*(::std::ptr::null::<_CONTEXT__bindgen_ty_1__bindgen_ty_1>())).Xmm8 as *const _
492 as usize
493 },
494 288usize,
495 concat!(
496 "Offset of field: ",
497 stringify!(_CONTEXT__bindgen_ty_1__bindgen_ty_1),
498 "::",
499 stringify!(Xmm8)
500 )
501 );
502 assert_eq!(
503 unsafe {
504 &(*(::std::ptr::null::<_CONTEXT__bindgen_ty_1__bindgen_ty_1>())).Xmm9 as *const _
505 as usize
506 },
507 304usize,
508 concat!(
509 "Offset of field: ",
510 stringify!(_CONTEXT__bindgen_ty_1__bindgen_ty_1),
511 "::",
512 stringify!(Xmm9)
513 )
514 );
515 assert_eq!(
516 unsafe {
517 &(*(::std::ptr::null::<_CONTEXT__bindgen_ty_1__bindgen_ty_1>())).Xmm10 as *const _
518 as usize
519 },
520 320usize,
521 concat!(
522 "Offset of field: ",
523 stringify!(_CONTEXT__bindgen_ty_1__bindgen_ty_1),
524 "::",
525 stringify!(Xmm10)
526 )
527 );
528 assert_eq!(
529 unsafe {
530 &(*(::std::ptr::null::<_CONTEXT__bindgen_ty_1__bindgen_ty_1>())).Xmm11 as *const _
531 as usize
532 },
533 336usize,
534 concat!(
535 "Offset of field: ",
536 stringify!(_CONTEXT__bindgen_ty_1__bindgen_ty_1),
537 "::",
538 stringify!(Xmm11)
539 )
540 );
541 assert_eq!(
542 unsafe {
543 &(*(::std::ptr::null::<_CONTEXT__bindgen_ty_1__bindgen_ty_1>())).Xmm12 as *const _
544 as usize
545 },
546 352usize,
547 concat!(
548 "Offset of field: ",
549 stringify!(_CONTEXT__bindgen_ty_1__bindgen_ty_1),
550 "::",
551 stringify!(Xmm12)
552 )
553 );
554 assert_eq!(
555 unsafe {
556 &(*(::std::ptr::null::<_CONTEXT__bindgen_ty_1__bindgen_ty_1>())).Xmm13 as *const _
557 as usize
558 },
559 368usize,
560 concat!(
561 "Offset of field: ",
562 stringify!(_CONTEXT__bindgen_ty_1__bindgen_ty_1),
563 "::",
564 stringify!(Xmm13)
565 )
566 );
567 assert_eq!(
568 unsafe {
569 &(*(::std::ptr::null::<_CONTEXT__bindgen_ty_1__bindgen_ty_1>())).Xmm14 as *const _
570 as usize
571 },
572 384usize,
573 concat!(
574 "Offset of field: ",
575 stringify!(_CONTEXT__bindgen_ty_1__bindgen_ty_1),
576 "::",
577 stringify!(Xmm14)
578 )
579 );
580 assert_eq!(
581 unsafe {
582 &(*(::std::ptr::null::<_CONTEXT__bindgen_ty_1__bindgen_ty_1>())).Xmm15 as *const _
583 as usize
584 },
585 400usize,
586 concat!(
587 "Offset of field: ",
588 stringify!(_CONTEXT__bindgen_ty_1__bindgen_ty_1),
589 "::",
590 stringify!(Xmm15)
591 )
592 );
593}
594#[test]
595fn bindgen_test_layout__CONTEXT__bindgen_ty_1() {
596 assert_eq!(
597 ::std::mem::size_of::<_CONTEXT__bindgen_ty_1>(),
598 512usize,
599 concat!("Size of: ", stringify!(_CONTEXT__bindgen_ty_1))
600 );
601 assert_eq!(
602 ::std::mem::align_of::<_CONTEXT__bindgen_ty_1>(),
603 16usize,
604 concat!("Alignment of ", stringify!(_CONTEXT__bindgen_ty_1))
605 );
606 assert_eq!(
607 unsafe { &(*(::std::ptr::null::<_CONTEXT__bindgen_ty_1>())).FltSave as *const _ as usize },
608 0usize,
609 concat!(
610 "Offset of field: ",
611 stringify!(_CONTEXT__bindgen_ty_1),
612 "::",
613 stringify!(FltSave)
614 )
615 );
616}
617#[test]
618fn bindgen_test_layout__CONTEXT() {
619 assert_eq!(
620 ::std::mem::size_of::<_CONTEXT>(),
621 1232usize,
622 concat!("Size of: ", stringify!(_CONTEXT))
623 );
624 assert_eq!(
625 ::std::mem::align_of::<_CONTEXT>(),
626 16usize,
627 concat!("Alignment of ", stringify!(_CONTEXT))
628 );
629 assert_eq!(
630 unsafe { &(*(::std::ptr::null::<_CONTEXT>())).P1Home as *const _ as usize },
631 0usize,
632 concat!(
633 "Offset of field: ",
634 stringify!(_CONTEXT),
635 "::",
636 stringify!(P1Home)
637 )
638 );
639 assert_eq!(
640 unsafe { &(*(::std::ptr::null::<_CONTEXT>())).P2Home as *const _ as usize },
641 8usize,
642 concat!(
643 "Offset of field: ",
644 stringify!(_CONTEXT),
645 "::",
646 stringify!(P2Home)
647 )
648 );
649 assert_eq!(
650 unsafe { &(*(::std::ptr::null::<_CONTEXT>())).P3Home as *const _ as usize },
651 16usize,
652 concat!(
653 "Offset of field: ",
654 stringify!(_CONTEXT),
655 "::",
656 stringify!(P3Home)
657 )
658 );
659 assert_eq!(
660 unsafe { &(*(::std::ptr::null::<_CONTEXT>())).P4Home as *const _ as usize },
661 24usize,
662 concat!(
663 "Offset of field: ",
664 stringify!(_CONTEXT),
665 "::",
666 stringify!(P4Home)
667 )
668 );
669 assert_eq!(
670 unsafe { &(*(::std::ptr::null::<_CONTEXT>())).P5Home as *const _ as usize },
671 32usize,
672 concat!(
673 "Offset of field: ",
674 stringify!(_CONTEXT),
675 "::",
676 stringify!(P5Home)
677 )
678 );
679 assert_eq!(
680 unsafe { &(*(::std::ptr::null::<_CONTEXT>())).P6Home as *const _ as usize },
681 40usize,
682 concat!(
683 "Offset of field: ",
684 stringify!(_CONTEXT),
685 "::",
686 stringify!(P6Home)
687 )
688 );
689 assert_eq!(
690 unsafe { &(*(::std::ptr::null::<_CONTEXT>())).ContextFlags as *const _ as usize },
691 48usize,
692 concat!(
693 "Offset of field: ",
694 stringify!(_CONTEXT),
695 "::",
696 stringify!(ContextFlags)
697 )
698 );
699 assert_eq!(
700 unsafe { &(*(::std::ptr::null::<_CONTEXT>())).MxCsr as *const _ as usize },
701 52usize,
702 concat!(
703 "Offset of field: ",
704 stringify!(_CONTEXT),
705 "::",
706 stringify!(MxCsr)
707 )
708 );
709 assert_eq!(
710 unsafe { &(*(::std::ptr::null::<_CONTEXT>())).SegCs as *const _ as usize },
711 56usize,
712 concat!(
713 "Offset of field: ",
714 stringify!(_CONTEXT),
715 "::",
716 stringify!(SegCs)
717 )
718 );
719 assert_eq!(
720 unsafe { &(*(::std::ptr::null::<_CONTEXT>())).SegDs as *const _ as usize },
721 58usize,
722 concat!(
723 "Offset of field: ",
724 stringify!(_CONTEXT),
725 "::",
726 stringify!(SegDs)
727 )
728 );
729 assert_eq!(
730 unsafe { &(*(::std::ptr::null::<_CONTEXT>())).SegEs as *const _ as usize },
731 60usize,
732 concat!(
733 "Offset of field: ",
734 stringify!(_CONTEXT),
735 "::",
736 stringify!(SegEs)
737 )
738 );
739 assert_eq!(
740 unsafe { &(*(::std::ptr::null::<_CONTEXT>())).SegFs as *const _ as usize },
741 62usize,
742 concat!(
743 "Offset of field: ",
744 stringify!(_CONTEXT),
745 "::",
746 stringify!(SegFs)
747 )
748 );
749 assert_eq!(
750 unsafe { &(*(::std::ptr::null::<_CONTEXT>())).SegGs as *const _ as usize },
751 64usize,
752 concat!(
753 "Offset of field: ",
754 stringify!(_CONTEXT),
755 "::",
756 stringify!(SegGs)
757 )
758 );
759 assert_eq!(
760 unsafe { &(*(::std::ptr::null::<_CONTEXT>())).SegSs as *const _ as usize },
761 66usize,
762 concat!(
763 "Offset of field: ",
764 stringify!(_CONTEXT),
765 "::",
766 stringify!(SegSs)
767 )
768 );
769 assert_eq!(
770 unsafe { &(*(::std::ptr::null::<_CONTEXT>())).EFlags as *const _ as usize },
771 68usize,
772 concat!(
773 "Offset of field: ",
774 stringify!(_CONTEXT),
775 "::",
776 stringify!(EFlags)
777 )
778 );
779 assert_eq!(
780 unsafe { &(*(::std::ptr::null::<_CONTEXT>())).Dr0 as *const _ as usize },
781 72usize,
782 concat!(
783 "Offset of field: ",
784 stringify!(_CONTEXT),
785 "::",
786 stringify!(Dr0)
787 )
788 );
789 assert_eq!(
790 unsafe { &(*(::std::ptr::null::<_CONTEXT>())).Dr1 as *const _ as usize },
791 80usize,
792 concat!(
793 "Offset of field: ",
794 stringify!(_CONTEXT),
795 "::",
796 stringify!(Dr1)
797 )
798 );
799 assert_eq!(
800 unsafe { &(*(::std::ptr::null::<_CONTEXT>())).Dr2 as *const _ as usize },
801 88usize,
802 concat!(
803 "Offset of field: ",
804 stringify!(_CONTEXT),
805 "::",
806 stringify!(Dr2)
807 )
808 );
809 assert_eq!(
810 unsafe { &(*(::std::ptr::null::<_CONTEXT>())).Dr3 as *const _ as usize },
811 96usize,
812 concat!(
813 "Offset of field: ",
814 stringify!(_CONTEXT),
815 "::",
816 stringify!(Dr3)
817 )
818 );
819 assert_eq!(
820 unsafe { &(*(::std::ptr::null::<_CONTEXT>())).Dr6 as *const _ as usize },
821 104usize,
822 concat!(
823 "Offset of field: ",
824 stringify!(_CONTEXT),
825 "::",
826 stringify!(Dr6)
827 )
828 );
829 assert_eq!(
830 unsafe { &(*(::std::ptr::null::<_CONTEXT>())).Dr7 as *const _ as usize },
831 112usize,
832 concat!(
833 "Offset of field: ",
834 stringify!(_CONTEXT),
835 "::",
836 stringify!(Dr7)
837 )
838 );
839 assert_eq!(
840 unsafe { &(*(::std::ptr::null::<_CONTEXT>())).Rax as *const _ as usize },
841 120usize,
842 concat!(
843 "Offset of field: ",
844 stringify!(_CONTEXT),
845 "::",
846 stringify!(Rax)
847 )
848 );
849 assert_eq!(
850 unsafe { &(*(::std::ptr::null::<_CONTEXT>())).Rcx as *const _ as usize },
851 128usize,
852 concat!(
853 "Offset of field: ",
854 stringify!(_CONTEXT),
855 "::",
856 stringify!(Rcx)
857 )
858 );
859 assert_eq!(
860 unsafe { &(*(::std::ptr::null::<_CONTEXT>())).Rdx as *const _ as usize },
861 136usize,
862 concat!(
863 "Offset of field: ",
864 stringify!(_CONTEXT),
865 "::",
866 stringify!(Rdx)
867 )
868 );
869 assert_eq!(
870 unsafe { &(*(::std::ptr::null::<_CONTEXT>())).Rbx as *const _ as usize },
871 144usize,
872 concat!(
873 "Offset of field: ",
874 stringify!(_CONTEXT),
875 "::",
876 stringify!(Rbx)
877 )
878 );
879 assert_eq!(
880 unsafe { &(*(::std::ptr::null::<_CONTEXT>())).Rsp as *const _ as usize },
881 152usize,
882 concat!(
883 "Offset of field: ",
884 stringify!(_CONTEXT),
885 "::",
886 stringify!(Rsp)
887 )
888 );
889 assert_eq!(
890 unsafe { &(*(::std::ptr::null::<_CONTEXT>())).Rbp as *const _ as usize },
891 160usize,
892 concat!(
893 "Offset of field: ",
894 stringify!(_CONTEXT),
895 "::",
896 stringify!(Rbp)
897 )
898 );
899 assert_eq!(
900 unsafe { &(*(::std::ptr::null::<_CONTEXT>())).Rsi as *const _ as usize },
901 168usize,
902 concat!(
903 "Offset of field: ",
904 stringify!(_CONTEXT),
905 "::",
906 stringify!(Rsi)
907 )
908 );
909 assert_eq!(
910 unsafe { &(*(::std::ptr::null::<_CONTEXT>())).Rdi as *const _ as usize },
911 176usize,
912 concat!(
913 "Offset of field: ",
914 stringify!(_CONTEXT),
915 "::",
916 stringify!(Rdi)
917 )
918 );
919 assert_eq!(
920 unsafe { &(*(::std::ptr::null::<_CONTEXT>())).R8 as *const _ as usize },
921 184usize,
922 concat!(
923 "Offset of field: ",
924 stringify!(_CONTEXT),
925 "::",
926 stringify!(R8)
927 )
928 );
929 assert_eq!(
930 unsafe { &(*(::std::ptr::null::<_CONTEXT>())).R9 as *const _ as usize },
931 192usize,
932 concat!(
933 "Offset of field: ",
934 stringify!(_CONTEXT),
935 "::",
936 stringify!(R9)
937 )
938 );
939 assert_eq!(
940 unsafe { &(*(::std::ptr::null::<_CONTEXT>())).R10 as *const _ as usize },
941 200usize,
942 concat!(
943 "Offset of field: ",
944 stringify!(_CONTEXT),
945 "::",
946 stringify!(R10)
947 )
948 );
949 assert_eq!(
950 unsafe { &(*(::std::ptr::null::<_CONTEXT>())).R11 as *const _ as usize },
951 208usize,
952 concat!(
953 "Offset of field: ",
954 stringify!(_CONTEXT),
955 "::",
956 stringify!(R11)
957 )
958 );
959 assert_eq!(
960 unsafe { &(*(::std::ptr::null::<_CONTEXT>())).R12 as *const _ as usize },
961 216usize,
962 concat!(
963 "Offset of field: ",
964 stringify!(_CONTEXT),
965 "::",
966 stringify!(R12)
967 )
968 );
969 assert_eq!(
970 unsafe { &(*(::std::ptr::null::<_CONTEXT>())).R13 as *const _ as usize },
971 224usize,
972 concat!(
973 "Offset of field: ",
974 stringify!(_CONTEXT),
975 "::",
976 stringify!(R13)
977 )
978 );
979 assert_eq!(
980 unsafe { &(*(::std::ptr::null::<_CONTEXT>())).R14 as *const _ as usize },
981 232usize,
982 concat!(
983 "Offset of field: ",
984 stringify!(_CONTEXT),
985 "::",
986 stringify!(R14)
987 )
988 );
989 assert_eq!(
990 unsafe { &(*(::std::ptr::null::<_CONTEXT>())).R15 as *const _ as usize },
991 240usize,
992 concat!(
993 "Offset of field: ",
994 stringify!(_CONTEXT),
995 "::",
996 stringify!(R15)
997 )
998 );
999 assert_eq!(
1000 unsafe { &(*(::std::ptr::null::<_CONTEXT>())).Rip as *const _ as usize },
1001 248usize,
1002 concat!(
1003 "Offset of field: ",
1004 stringify!(_CONTEXT),
1005 "::",
1006 stringify!(Rip)
1007 )
1008 );
1009 assert_eq!(
1010 unsafe { &(*(::std::ptr::null::<_CONTEXT>())).VectorRegister as *const _ as usize },
1011 768usize,
1012 concat!(
1013 "Offset of field: ",
1014 stringify!(_CONTEXT),
1015 "::",
1016 stringify!(VectorRegister)
1017 )
1018 );
1019 assert_eq!(
1020 unsafe { &(*(::std::ptr::null::<_CONTEXT>())).VectorControl as *const _ as usize },
1021 1184usize,
1022 concat!(
1023 "Offset of field: ",
1024 stringify!(_CONTEXT),
1025 "::",
1026 stringify!(VectorControl)
1027 )
1028 );
1029 assert_eq!(
1030 unsafe { &(*(::std::ptr::null::<_CONTEXT>())).DebugControl as *const _ as usize },
1031 1192usize,
1032 concat!(
1033 "Offset of field: ",
1034 stringify!(_CONTEXT),
1035 "::",
1036 stringify!(DebugControl)
1037 )
1038 );
1039 assert_eq!(
1040 unsafe { &(*(::std::ptr::null::<_CONTEXT>())).LastBranchToRip as *const _ as usize },
1041 1200usize,
1042 concat!(
1043 "Offset of field: ",
1044 stringify!(_CONTEXT),
1045 "::",
1046 stringify!(LastBranchToRip)
1047 )
1048 );
1049 assert_eq!(
1050 unsafe { &(*(::std::ptr::null::<_CONTEXT>())).LastBranchFromRip as *const _ as usize },
1051 1208usize,
1052 concat!(
1053 "Offset of field: ",
1054 stringify!(_CONTEXT),
1055 "::",
1056 stringify!(LastBranchFromRip)
1057 )
1058 );
1059 assert_eq!(
1060 unsafe { &(*(::std::ptr::null::<_CONTEXT>())).LastExceptionToRip as *const _ as usize },
1061 1216usize,
1062 concat!(
1063 "Offset of field: ",
1064 stringify!(_CONTEXT),
1065 "::",
1066 stringify!(LastExceptionToRip)
1067 )
1068 );
1069 assert_eq!(
1070 unsafe { &(*(::std::ptr::null::<_CONTEXT>())).LastExceptionFromRip as *const _ as usize },
1071 1224usize,
1072 concat!(
1073 "Offset of field: ",
1074 stringify!(_CONTEXT),
1075 "::",
1076 stringify!(LastExceptionFromRip)
1077 )
1078 );
1079}
1080pub type PCONTEXT = *mut _CONTEXT;
1081#[repr(C)]
1082#[derive(Debug, Copy, Clone)]
1083pub struct _EXCEPTION_RECORD {
1084 pub ExceptionCode: DWORD,
1085 pub ExceptionFlags: DWORD,
1086 pub ExceptionRecord: *mut _EXCEPTION_RECORD,
1087 pub ExceptionAddress: PVOID,
1088 pub NumberParameters: DWORD,
1089 pub ExceptionInformation: [ULONG_PTR; 15usize],
1090}
1091#[test]
1092fn bindgen_test_layout__EXCEPTION_RECORD() {
1093 assert_eq!(
1094 ::std::mem::size_of::<_EXCEPTION_RECORD>(),
1095 152usize,
1096 concat!("Size of: ", stringify!(_EXCEPTION_RECORD))
1097 );
1098 assert_eq!(
1099 ::std::mem::align_of::<_EXCEPTION_RECORD>(),
1100 8usize,
1101 concat!("Alignment of ", stringify!(_EXCEPTION_RECORD))
1102 );
1103 assert_eq!(
1104 unsafe { &(*(::std::ptr::null::<_EXCEPTION_RECORD>())).ExceptionCode as *const _ as usize },
1105 0usize,
1106 concat!(
1107 "Offset of field: ",
1108 stringify!(_EXCEPTION_RECORD),
1109 "::",
1110 stringify!(ExceptionCode)
1111 )
1112 );
1113 assert_eq!(
1114 unsafe {
1115 &(*(::std::ptr::null::<_EXCEPTION_RECORD>())).ExceptionFlags as *const _ as usize
1116 },
1117 4usize,
1118 concat!(
1119 "Offset of field: ",
1120 stringify!(_EXCEPTION_RECORD),
1121 "::",
1122 stringify!(ExceptionFlags)
1123 )
1124 );
1125 assert_eq!(
1126 unsafe {
1127 &(*(::std::ptr::null::<_EXCEPTION_RECORD>())).ExceptionRecord as *const _ as usize
1128 },
1129 8usize,
1130 concat!(
1131 "Offset of field: ",
1132 stringify!(_EXCEPTION_RECORD),
1133 "::",
1134 stringify!(ExceptionRecord)
1135 )
1136 );
1137 assert_eq!(
1138 unsafe {
1139 &(*(::std::ptr::null::<_EXCEPTION_RECORD>())).ExceptionAddress as *const _ as usize
1140 },
1141 16usize,
1142 concat!(
1143 "Offset of field: ",
1144 stringify!(_EXCEPTION_RECORD),
1145 "::",
1146 stringify!(ExceptionAddress)
1147 )
1148 );
1149 assert_eq!(
1150 unsafe {
1151 &(*(::std::ptr::null::<_EXCEPTION_RECORD>())).NumberParameters as *const _ as usize
1152 },
1153 24usize,
1154 concat!(
1155 "Offset of field: ",
1156 stringify!(_EXCEPTION_RECORD),
1157 "::",
1158 stringify!(NumberParameters)
1159 )
1160 );
1161 assert_eq!(
1162 unsafe {
1163 &(*(::std::ptr::null::<_EXCEPTION_RECORD>())).ExceptionInformation as *const _ as usize
1164 },
1165 32usize,
1166 concat!(
1167 "Offset of field: ",
1168 stringify!(_EXCEPTION_RECORD),
1169 "::",
1170 stringify!(ExceptionInformation)
1171 )
1172 );
1173}
1174pub type EXCEPTION_RECORD = _EXCEPTION_RECORD;
1175pub type PEXCEPTION_RECORD = *mut EXCEPTION_RECORD;
1176#[repr(C)]
1177#[derive(Debug, Copy, Clone)]
1178pub struct _EXCEPTION_POINTERS {
1179 pub ExceptionRecord: PEXCEPTION_RECORD,
1180 pub ContextRecord: PCONTEXT,
1181}
1182#[test]
1183fn bindgen_test_layout__EXCEPTION_POINTERS() {
1184 assert_eq!(
1185 ::std::mem::size_of::<_EXCEPTION_POINTERS>(),
1186 16usize,
1187 concat!("Size of: ", stringify!(_EXCEPTION_POINTERS))
1188 );
1189 assert_eq!(
1190 ::std::mem::align_of::<_EXCEPTION_POINTERS>(),
1191 8usize,
1192 concat!("Alignment of ", stringify!(_EXCEPTION_POINTERS))
1193 );
1194 assert_eq!(
1195 unsafe {
1196 &(*(::std::ptr::null::<_EXCEPTION_POINTERS>())).ExceptionRecord as *const _ as usize
1197 },
1198 0usize,
1199 concat!(
1200 "Offset of field: ",
1201 stringify!(_EXCEPTION_POINTERS),
1202 "::",
1203 stringify!(ExceptionRecord)
1204 )
1205 );
1206 assert_eq!(
1207 unsafe {
1208 &(*(::std::ptr::null::<_EXCEPTION_POINTERS>())).ContextRecord as *const _ as usize
1209 },
1210 8usize,
1211 concat!(
1212 "Offset of field: ",
1213 stringify!(_EXCEPTION_POINTERS),
1214 "::",
1215 stringify!(ContextRecord)
1216 )
1217 );
1218}
1219pub type FARPROC = ::std::option::Option<unsafe extern "C" fn() -> INT_PTR>;
1220pub type std_integral_constant_value_type<_Ty> = _Ty;
1221pub type std_integral_constant_type = u8;
1222pub type std_true_type = u8;
1223pub type std_conditional_type<_Ty1> = _Ty1;
1224pub type std_conditional_t = u8;
1225#[repr(C)]
1226#[derive(Debug, Copy, Clone)]
1227pub struct std_input_iterator_tag {
1228 pub _address: u8,
1229}
1230#[test]
1231fn bindgen_test_layout_std_input_iterator_tag() {
1232 assert_eq!(
1233 ::std::mem::size_of::<std_input_iterator_tag>(),
1234 1usize,
1235 concat!("Size of: ", stringify!(std_input_iterator_tag))
1236 );
1237 assert_eq!(
1238 ::std::mem::align_of::<std_input_iterator_tag>(),
1239 1usize,
1240 concat!("Alignment of ", stringify!(std_input_iterator_tag))
1241 );
1242}
1243#[repr(C)]
1244#[derive(Debug, Copy, Clone)]
1245pub struct std_forward_iterator_tag {
1246 pub _address: u8,
1247}
1248#[test]
1249fn bindgen_test_layout_std_forward_iterator_tag() {
1250 assert_eq!(
1251 ::std::mem::size_of::<std_forward_iterator_tag>(),
1252 1usize,
1253 concat!("Size of: ", stringify!(std_forward_iterator_tag))
1254 );
1255 assert_eq!(
1256 ::std::mem::align_of::<std_forward_iterator_tag>(),
1257 1usize,
1258 concat!("Alignment of ", stringify!(std_forward_iterator_tag))
1259 );
1260}
1261#[repr(C)]
1262#[derive(Debug, Copy, Clone)]
1263pub struct std_bidirectional_iterator_tag {
1264 pub _address: u8,
1265}
1266#[test]
1267fn bindgen_test_layout_std_bidirectional_iterator_tag() {
1268 assert_eq!(
1269 ::std::mem::size_of::<std_bidirectional_iterator_tag>(),
1270 1usize,
1271 concat!("Size of: ", stringify!(std_bidirectional_iterator_tag))
1272 );
1273 assert_eq!(
1274 ::std::mem::align_of::<std_bidirectional_iterator_tag>(),
1275 1usize,
1276 concat!("Alignment of ", stringify!(std_bidirectional_iterator_tag))
1277 );
1278}
1279#[repr(C)]
1280#[derive(Debug, Copy, Clone)]
1281pub struct std_random_access_iterator_tag {
1282 pub _address: u8,
1283}
1284#[test]
1285fn bindgen_test_layout_std_random_access_iterator_tag() {
1286 assert_eq!(
1287 ::std::mem::size_of::<std_random_access_iterator_tag>(),
1288 1usize,
1289 concat!("Size of: ", stringify!(std_random_access_iterator_tag))
1290 );
1291 assert_eq!(
1292 ::std::mem::align_of::<std_random_access_iterator_tag>(),
1293 1usize,
1294 concat!("Alignment of ", stringify!(std_random_access_iterator_tag))
1295 );
1296}
1297#[repr(C)]
1298#[derive(Debug, Copy, Clone)]
1299pub struct std__Iterator_traits_base {
1300 pub _address: u8,
1301}
1302#[repr(C)]
1303#[derive(Debug, Copy, Clone)]
1304pub struct std_iterator_traits {
1305 pub _address: u8,
1306}
1307#[repr(C)]
1308#[derive(Debug, Copy, Clone)]
1309pub struct std_reverse_iterator<_BidIt> {
1310 pub current: _BidIt,
1311 pub _phantom_0: ::std::marker::PhantomData<::std::cell::UnsafeCell<_BidIt>>,
1312}
1313pub type std_reverse_iterator_iterator_type<_BidIt> = _BidIt;
1314pub type std_reverse_iterator_iterator_category = std_iterator_traits;
1315pub type std_reverse_iterator_value_type = std_iterator_traits;
1316pub type std_reverse_iterator_difference_type = std_iterator_traits;
1317pub type std_reverse_iterator_pointer = std_iterator_traits;
1318pub type std_reverse_iterator_reference = std_iterator_traits;
1319pub type std_reverse_iterator__Prevent_inheriting_unwrap<_BidIt> = std_reverse_iterator<_BidIt>;
1320#[repr(C)]
1321#[derive(Debug, Copy, Clone)]
1322pub struct std_allocator_traits {
1323 pub _address: u8,
1324}
1325pub type std__Rebind_alloc_t = std_allocator_traits;
1326#[repr(C)]
1327#[derive(Debug, Copy, Clone)]
1328pub struct std_allocator {
1329 pub _address: u8,
1330}
1331pub type std_allocator__From_primary = std_allocator;
1332pub type std_allocator_value_type<_Ty> = _Ty;
1333pub type std_allocator_pointer<_Ty> = *mut _Ty;
1334pub type std_allocator_const_pointer<_Ty> = *const _Ty;
1335pub type std_allocator_reference<_Ty> = *mut _Ty;
1336pub type std_allocator_const_reference<_Ty> = *const _Ty;
1337pub type std_allocator_size_type = size_t;
1338pub type std_allocator_difference_type = isize;
1339pub type std_allocator_propagate_on_container_move_assignment = std_true_type;
1340pub type std_allocator_is_always_equal = std_true_type;
1341#[repr(C)]
1342#[derive(Debug, Copy, Clone)]
1343pub struct std_allocator_rebind {
1344 pub _address: u8,
1345}
1346pub type std_allocator_rebind_other = std_allocator;
1347#[repr(C)]
1348#[derive(Debug, Copy, Clone)]
1349pub struct std__Container_base0 {
1350 pub _address: u8,
1351}
1352#[test]
1353fn bindgen_test_layout_std__Container_base0() {
1354 assert_eq!(
1355 ::std::mem::size_of::<std__Container_base0>(),
1356 1usize,
1357 concat!("Size of: ", stringify!(std__Container_base0))
1358 );
1359 assert_eq!(
1360 ::std::mem::align_of::<std__Container_base0>(),
1361 1usize,
1362 concat!("Alignment of ", stringify!(std__Container_base0))
1363 );
1364}
1365#[repr(C)]
1366#[derive(Debug, Copy, Clone)]
1367pub struct std__Iterator_base0 {
1368 pub _address: u8,
1369}
1370pub const std__Iterator_base0__Unwrap_when_unverified: bool = true;
1371#[test]
1372fn bindgen_test_layout_std__Iterator_base0() {
1373 assert_eq!(
1374 ::std::mem::size_of::<std__Iterator_base0>(),
1375 1usize,
1376 concat!("Size of: ", stringify!(std__Iterator_base0))
1377 );
1378 assert_eq!(
1379 ::std::mem::align_of::<std__Iterator_base0>(),
1380 1usize,
1381 concat!("Alignment of ", stringify!(std__Iterator_base0))
1382 );
1383}
1384pub type std__Container_base = std__Container_base0;
1385pub type std__Iterator_base = std__Iterator_base0;
1386pub type std__Compressed_pair__Mybase<_Ty1> = _Ty1;
1387#[repr(C)]
1388pub struct std__Vector_const_iterator {
1389 pub _Ptr: std__Vector_const_iterator__Tptr,
1390}
1391pub type std__Vector_const_iterator_iterator_category = std_random_access_iterator_tag;
1392pub type std__Vector_const_iterator_value_type = [u8; 0usize];
1393pub type std__Vector_const_iterator_difference_type = [u8; 0usize];
1394pub type std__Vector_const_iterator_pointer = [u8; 0usize];
1395pub type std__Vector_const_iterator_reference = *const std__Vector_const_iterator_value_type;
1396pub type std__Vector_const_iterator__Tptr = [u8; 0usize];
1397pub type std__Vector_const_iterator__Prevent_inheriting_unwrap = std__Vector_const_iterator;
1398#[repr(C)]
1399pub struct std__Vector_iterator {
1400 pub _base: std__Vector_const_iterator,
1401}
1402pub type std__Vector_iterator__Mybase = std__Vector_const_iterator;
1403pub type std__Vector_iterator_iterator_category = std_random_access_iterator_tag;
1404pub type std__Vector_iterator_value_type = [u8; 0usize];
1405pub type std__Vector_iterator_difference_type = [u8; 0usize];
1406pub type std__Vector_iterator_pointer = [u8; 0usize];
1407pub type std__Vector_iterator_reference = *mut std__Vector_iterator_value_type;
1408pub type std__Vector_iterator__Prevent_inheriting_unwrap = std__Vector_iterator;
1409#[repr(C)]
1410pub struct std__Vector_val {
1411 pub _Myfirst: std__Vector_val_pointer,
1412 pub _Mylast: std__Vector_val_pointer,
1413 pub _Myend: std__Vector_val_pointer,
1414}
1415pub type std__Vector_val_value_type = [u8; 0usize];
1416pub type std__Vector_val_size_type = [u8; 0usize];
1417pub type std__Vector_val_difference_type = [u8; 0usize];
1418pub type std__Vector_val_pointer = [u8; 0usize];
1419pub type std__Vector_val_const_pointer = [u8; 0usize];
1420pub type std__Vector_val_reference = *mut std__Vector_val_value_type;
1421pub type std__Vector_val_const_reference = *const std__Vector_val_value_type;
1422#[repr(C)]
1423#[derive(Debug)]
1424pub struct std_vector {
1425 pub _Mypair: u8,
1426}
1427pub type std_vector__Alty = std__Rebind_alloc_t;
1428pub type std_vector__Alty_traits = std_allocator_traits;
1429pub type std_vector_value_type<_Ty> = _Ty;
1430pub type std_vector_allocator_type<_Alloc> = _Alloc;
1431pub type std_vector_pointer = std_vector__Alty_traits;
1432pub type std_vector_const_pointer = std_vector__Alty_traits;
1433pub type std_vector_reference<_Ty> = *mut _Ty;
1434pub type std_vector_const_reference<_Ty> = *const _Ty;
1435pub type std_vector_size_type = std_vector__Alty_traits;
1436pub type std_vector_difference_type = std_vector__Alty_traits;
1437pub type std_vector__Scary_val = std__Vector_val;
1438pub type std_vector_iterator = std__Vector_iterator;
1439pub type std_vector_const_iterator = std__Vector_const_iterator;
1440pub type std_vector_reverse_iterator = std_reverse_iterator<std_vector_iterator>;
1441pub type std_vector_const_reverse_iterator = std_reverse_iterator<std_vector_const_iterator>;
1442#[repr(C)]
1443#[derive(Debug, Copy, Clone)]
1444pub struct std_default_delete {
1445 pub _address: u8,
1446}
1447#[repr(C)]
1448#[derive(Debug, Copy, Clone)]
1449pub struct std__Get_deleter_pointer_type {
1450 pub _address: u8,
1451}
1452pub type std__Get_deleter_pointer_type_type<_Ty> = *mut _Ty;
1453#[repr(C)]
1454#[derive(Debug)]
1455pub struct std_unique_ptr {
1456 pub _Mypair: u8,
1457}
1458pub type std_unique_ptr_pointer = std__Get_deleter_pointer_type;
1459pub type std_unique_ptr_element_type<_Ty> = _Ty;
1460pub type std_unique_ptr_deleter_type<_Dx> = _Dx;
1461#[repr(C)]
1462#[derive(Debug)]
1463pub struct std_thread {
1464 pub _Thr: _Thrd_t,
1465}
1466pub type std_thread_native_handle_type = *mut ::std::os::raw::c_void;
1467#[test]
1468fn bindgen_test_layout_std_thread() {
1469 assert_eq!(
1470 ::std::mem::size_of::<std_thread>(),
1471 16usize,
1472 concat!("Size of: ", stringify!(std_thread))
1473 );
1474 assert_eq!(
1475 ::std::mem::align_of::<std_thread>(),
1476 8usize,
1477 concat!("Alignment of ", stringify!(std_thread))
1478 );
1479 assert_eq!(
1480 unsafe { &(*(::std::ptr::null::<std_thread>()))._Thr as *const _ as usize },
1481 0usize,
1482 concat!(
1483 "Offset of field: ",
1484 stringify!(std_thread),
1485 "::",
1486 stringify!(_Thr)
1487 )
1488 );
1489}
1490extern "C" {
1491 #[link_name = "\u{1}?get_id@thread@std@@QEBA?AVid@12@XZ"]
1492 pub fn std_thread_get_id(this: *const std_thread) -> std_thread_id;
1493}
1494impl std_thread {
1495 #[inline]
1496 pub unsafe fn get_id(&self) -> std_thread_id {
1497 std_thread_get_id(self)
1498 }
1499}
1500#[repr(C)]
1501#[derive(Debug, Copy, Clone)]
1502pub struct std_thread_id {
1503 pub _Id: _Thrd_id_t,
1504}
1505#[test]
1506fn bindgen_test_layout_std_thread_id() {
1507 assert_eq!(
1508 ::std::mem::size_of::<std_thread_id>(),
1509 4usize,
1510 concat!("Size of: ", stringify!(std_thread_id))
1511 );
1512 assert_eq!(
1513 ::std::mem::align_of::<std_thread_id>(),
1514 4usize,
1515 concat!("Alignment of ", stringify!(std_thread_id))
1516 );
1517 assert_eq!(
1518 unsafe { &(*(::std::ptr::null::<std_thread_id>()))._Id as *const _ as usize },
1519 0usize,
1520 concat!(
1521 "Offset of field: ",
1522 stringify!(std_thread_id),
1523 "::",
1524 stringify!(_Id)
1525 )
1526 );
1527}
1528pub const _VIGEM_TARGET_TYPE_Xbox360Wired: _VIGEM_TARGET_TYPE = 0;
1529pub const _VIGEM_TARGET_TYPE_DualShock4Wired: _VIGEM_TARGET_TYPE = 2;
1530pub type _VIGEM_TARGET_TYPE = i32;
1531pub use self::_VIGEM_TARGET_TYPE as VIGEM_TARGET_TYPE;
1532pub const _XUSB_BUTTON_XUSB_GAMEPAD_DPAD_UP: _XUSB_BUTTON = 1;
1533pub const _XUSB_BUTTON_XUSB_GAMEPAD_DPAD_DOWN: _XUSB_BUTTON = 2;
1534pub const _XUSB_BUTTON_XUSB_GAMEPAD_DPAD_LEFT: _XUSB_BUTTON = 4;
1535pub const _XUSB_BUTTON_XUSB_GAMEPAD_DPAD_RIGHT: _XUSB_BUTTON = 8;
1536pub const _XUSB_BUTTON_XUSB_GAMEPAD_START: _XUSB_BUTTON = 16;
1537pub const _XUSB_BUTTON_XUSB_GAMEPAD_BACK: _XUSB_BUTTON = 32;
1538pub const _XUSB_BUTTON_XUSB_GAMEPAD_LEFT_THUMB: _XUSB_BUTTON = 64;
1539pub const _XUSB_BUTTON_XUSB_GAMEPAD_RIGHT_THUMB: _XUSB_BUTTON = 128;
1540pub const _XUSB_BUTTON_XUSB_GAMEPAD_LEFT_SHOULDER: _XUSB_BUTTON = 256;
1541pub const _XUSB_BUTTON_XUSB_GAMEPAD_RIGHT_SHOULDER: _XUSB_BUTTON = 512;
1542pub const _XUSB_BUTTON_XUSB_GAMEPAD_GUIDE: _XUSB_BUTTON = 1024;
1543pub const _XUSB_BUTTON_XUSB_GAMEPAD_A: _XUSB_BUTTON = 4096;
1544pub const _XUSB_BUTTON_XUSB_GAMEPAD_B: _XUSB_BUTTON = 8192;
1545pub const _XUSB_BUTTON_XUSB_GAMEPAD_X: _XUSB_BUTTON = 16384;
1546pub const _XUSB_BUTTON_XUSB_GAMEPAD_Y: _XUSB_BUTTON = 32768;
1547pub type _XUSB_BUTTON = i32;
1548#[repr(C)]
1549#[derive(Debug, Copy, Clone)]
1550pub struct _XUSB_REPORT {
1551 pub wButtons: USHORT,
1552 pub bLeftTrigger: BYTE,
1553 pub bRightTrigger: BYTE,
1554 pub sThumbLX: SHORT,
1555 pub sThumbLY: SHORT,
1556 pub sThumbRX: SHORT,
1557 pub sThumbRY: SHORT,
1558}
1559#[test]
1560fn bindgen_test_layout__XUSB_REPORT() {
1561 assert_eq!(
1562 ::std::mem::size_of::<_XUSB_REPORT>(),
1563 12usize,
1564 concat!("Size of: ", stringify!(_XUSB_REPORT))
1565 );
1566 assert_eq!(
1567 ::std::mem::align_of::<_XUSB_REPORT>(),
1568 2usize,
1569 concat!("Alignment of ", stringify!(_XUSB_REPORT))
1570 );
1571 assert_eq!(
1572 unsafe { &(*(::std::ptr::null::<_XUSB_REPORT>())).wButtons as *const _ as usize },
1573 0usize,
1574 concat!(
1575 "Offset of field: ",
1576 stringify!(_XUSB_REPORT),
1577 "::",
1578 stringify!(wButtons)
1579 )
1580 );
1581 assert_eq!(
1582 unsafe { &(*(::std::ptr::null::<_XUSB_REPORT>())).bLeftTrigger as *const _ as usize },
1583 2usize,
1584 concat!(
1585 "Offset of field: ",
1586 stringify!(_XUSB_REPORT),
1587 "::",
1588 stringify!(bLeftTrigger)
1589 )
1590 );
1591 assert_eq!(
1592 unsafe { &(*(::std::ptr::null::<_XUSB_REPORT>())).bRightTrigger as *const _ as usize },
1593 3usize,
1594 concat!(
1595 "Offset of field: ",
1596 stringify!(_XUSB_REPORT),
1597 "::",
1598 stringify!(bRightTrigger)
1599 )
1600 );
1601 assert_eq!(
1602 unsafe { &(*(::std::ptr::null::<_XUSB_REPORT>())).sThumbLX as *const _ as usize },
1603 4usize,
1604 concat!(
1605 "Offset of field: ",
1606 stringify!(_XUSB_REPORT),
1607 "::",
1608 stringify!(sThumbLX)
1609 )
1610 );
1611 assert_eq!(
1612 unsafe { &(*(::std::ptr::null::<_XUSB_REPORT>())).sThumbLY as *const _ as usize },
1613 6usize,
1614 concat!(
1615 "Offset of field: ",
1616 stringify!(_XUSB_REPORT),
1617 "::",
1618 stringify!(sThumbLY)
1619 )
1620 );
1621 assert_eq!(
1622 unsafe { &(*(::std::ptr::null::<_XUSB_REPORT>())).sThumbRX as *const _ as usize },
1623 8usize,
1624 concat!(
1625 "Offset of field: ",
1626 stringify!(_XUSB_REPORT),
1627 "::",
1628 stringify!(sThumbRX)
1629 )
1630 );
1631 assert_eq!(
1632 unsafe { &(*(::std::ptr::null::<_XUSB_REPORT>())).sThumbRY as *const _ as usize },
1633 10usize,
1634 concat!(
1635 "Offset of field: ",
1636 stringify!(_XUSB_REPORT),
1637 "::",
1638 stringify!(sThumbRY)
1639 )
1640 );
1641}
1642pub type XUSB_REPORT = _XUSB_REPORT;
1643#[repr(C)]
1644#[derive(Debug, Copy, Clone)]
1645pub struct _DS4_LIGHTBAR_COLOR {
1646 pub Red: UCHAR,
1647 pub Green: UCHAR,
1648 pub Blue: UCHAR,
1649}
1650#[test]
1651fn bindgen_test_layout__DS4_LIGHTBAR_COLOR() {
1652 assert_eq!(
1653 ::std::mem::size_of::<_DS4_LIGHTBAR_COLOR>(),
1654 3usize,
1655 concat!("Size of: ", stringify!(_DS4_LIGHTBAR_COLOR))
1656 );
1657 assert_eq!(
1658 ::std::mem::align_of::<_DS4_LIGHTBAR_COLOR>(),
1659 1usize,
1660 concat!("Alignment of ", stringify!(_DS4_LIGHTBAR_COLOR))
1661 );
1662 assert_eq!(
1663 unsafe { &(*(::std::ptr::null::<_DS4_LIGHTBAR_COLOR>())).Red as *const _ as usize },
1664 0usize,
1665 concat!(
1666 "Offset of field: ",
1667 stringify!(_DS4_LIGHTBAR_COLOR),
1668 "::",
1669 stringify!(Red)
1670 )
1671 );
1672 assert_eq!(
1673 unsafe { &(*(::std::ptr::null::<_DS4_LIGHTBAR_COLOR>())).Green as *const _ as usize },
1674 1usize,
1675 concat!(
1676 "Offset of field: ",
1677 stringify!(_DS4_LIGHTBAR_COLOR),
1678 "::",
1679 stringify!(Green)
1680 )
1681 );
1682 assert_eq!(
1683 unsafe { &(*(::std::ptr::null::<_DS4_LIGHTBAR_COLOR>())).Blue as *const _ as usize },
1684 2usize,
1685 concat!(
1686 "Offset of field: ",
1687 stringify!(_DS4_LIGHTBAR_COLOR),
1688 "::",
1689 stringify!(Blue)
1690 )
1691 );
1692}
1693pub type DS4_LIGHTBAR_COLOR = _DS4_LIGHTBAR_COLOR;
1694pub const _DS4_BUTTONS_DS4_BUTTON_THUMB_RIGHT: _DS4_BUTTONS = 32768;
1695pub const _DS4_BUTTONS_DS4_BUTTON_THUMB_LEFT: _DS4_BUTTONS = 16384;
1696pub const _DS4_BUTTONS_DS4_BUTTON_OPTIONS: _DS4_BUTTONS = 8192;
1697pub const _DS4_BUTTONS_DS4_BUTTON_SHARE: _DS4_BUTTONS = 4096;
1698pub const _DS4_BUTTONS_DS4_BUTTON_TRIGGER_RIGHT: _DS4_BUTTONS = 2048;
1699pub const _DS4_BUTTONS_DS4_BUTTON_TRIGGER_LEFT: _DS4_BUTTONS = 1024;
1700pub const _DS4_BUTTONS_DS4_BUTTON_SHOULDER_RIGHT: _DS4_BUTTONS = 512;
1701pub const _DS4_BUTTONS_DS4_BUTTON_SHOULDER_LEFT: _DS4_BUTTONS = 256;
1702pub const _DS4_BUTTONS_DS4_BUTTON_TRIANGLE: _DS4_BUTTONS = 128;
1703pub const _DS4_BUTTONS_DS4_BUTTON_CIRCLE: _DS4_BUTTONS = 64;
1704pub const _DS4_BUTTONS_DS4_BUTTON_CROSS: _DS4_BUTTONS = 32;
1705pub const _DS4_BUTTONS_DS4_BUTTON_SQUARE: _DS4_BUTTONS = 16;
1706pub type _DS4_BUTTONS = i32;
1707pub const _DS4_SPECIAL_BUTTONS_DS4_SPECIAL_BUTTON_PS: _DS4_SPECIAL_BUTTONS = 1;
1708pub const _DS4_SPECIAL_BUTTONS_DS4_SPECIAL_BUTTON_TOUCHPAD: _DS4_SPECIAL_BUTTONS = 2;
1709pub type _DS4_SPECIAL_BUTTONS = i32;
1710pub const _DS4_DPAD_DIRECTIONS_DS4_BUTTON_DPAD_NONE: _DS4_DPAD_DIRECTIONS = 8;
1711pub const _DS4_DPAD_DIRECTIONS_DS4_BUTTON_DPAD_NORTHWEST: _DS4_DPAD_DIRECTIONS = 7;
1712pub const _DS4_DPAD_DIRECTIONS_DS4_BUTTON_DPAD_WEST: _DS4_DPAD_DIRECTIONS = 6;
1713pub const _DS4_DPAD_DIRECTIONS_DS4_BUTTON_DPAD_SOUTHWEST: _DS4_DPAD_DIRECTIONS = 5;
1714pub const _DS4_DPAD_DIRECTIONS_DS4_BUTTON_DPAD_SOUTH: _DS4_DPAD_DIRECTIONS = 4;
1715pub const _DS4_DPAD_DIRECTIONS_DS4_BUTTON_DPAD_SOUTHEAST: _DS4_DPAD_DIRECTIONS = 3;
1716pub const _DS4_DPAD_DIRECTIONS_DS4_BUTTON_DPAD_EAST: _DS4_DPAD_DIRECTIONS = 2;
1717pub const _DS4_DPAD_DIRECTIONS_DS4_BUTTON_DPAD_NORTHEAST: _DS4_DPAD_DIRECTIONS = 1;
1718pub const _DS4_DPAD_DIRECTIONS_DS4_BUTTON_DPAD_NORTH: _DS4_DPAD_DIRECTIONS = 0;
1719pub type _DS4_DPAD_DIRECTIONS = i32;
1720#[repr(C)]
1721#[derive(Debug, Copy, Clone)]
1722pub struct _DS4_REPORT {
1723 pub bThumbLX: BYTE,
1724 pub bThumbLY: BYTE,
1725 pub bThumbRX: BYTE,
1726 pub bThumbRY: BYTE,
1727 pub wButtons: USHORT,
1728 pub bSpecial: BYTE,
1729 pub bTriggerL: BYTE,
1730 pub bTriggerR: BYTE,
1731}
1732#[test]
1733fn bindgen_test_layout__DS4_REPORT() {
1734 assert_eq!(
1735 ::std::mem::size_of::<_DS4_REPORT>(),
1736 10usize,
1737 concat!("Size of: ", stringify!(_DS4_REPORT))
1738 );
1739 assert_eq!(
1740 ::std::mem::align_of::<_DS4_REPORT>(),
1741 2usize,
1742 concat!("Alignment of ", stringify!(_DS4_REPORT))
1743 );
1744 assert_eq!(
1745 unsafe { &(*(::std::ptr::null::<_DS4_REPORT>())).bThumbLX as *const _ as usize },
1746 0usize,
1747 concat!(
1748 "Offset of field: ",
1749 stringify!(_DS4_REPORT),
1750 "::",
1751 stringify!(bThumbLX)
1752 )
1753 );
1754 assert_eq!(
1755 unsafe { &(*(::std::ptr::null::<_DS4_REPORT>())).bThumbLY as *const _ as usize },
1756 1usize,
1757 concat!(
1758 "Offset of field: ",
1759 stringify!(_DS4_REPORT),
1760 "::",
1761 stringify!(bThumbLY)
1762 )
1763 );
1764 assert_eq!(
1765 unsafe { &(*(::std::ptr::null::<_DS4_REPORT>())).bThumbRX as *const _ as usize },
1766 2usize,
1767 concat!(
1768 "Offset of field: ",
1769 stringify!(_DS4_REPORT),
1770 "::",
1771 stringify!(bThumbRX)
1772 )
1773 );
1774 assert_eq!(
1775 unsafe { &(*(::std::ptr::null::<_DS4_REPORT>())).bThumbRY as *const _ as usize },
1776 3usize,
1777 concat!(
1778 "Offset of field: ",
1779 stringify!(_DS4_REPORT),
1780 "::",
1781 stringify!(bThumbRY)
1782 )
1783 );
1784 assert_eq!(
1785 unsafe { &(*(::std::ptr::null::<_DS4_REPORT>())).wButtons as *const _ as usize },
1786 4usize,
1787 concat!(
1788 "Offset of field: ",
1789 stringify!(_DS4_REPORT),
1790 "::",
1791 stringify!(wButtons)
1792 )
1793 );
1794 assert_eq!(
1795 unsafe { &(*(::std::ptr::null::<_DS4_REPORT>())).bSpecial as *const _ as usize },
1796 6usize,
1797 concat!(
1798 "Offset of field: ",
1799 stringify!(_DS4_REPORT),
1800 "::",
1801 stringify!(bSpecial)
1802 )
1803 );
1804 assert_eq!(
1805 unsafe { &(*(::std::ptr::null::<_DS4_REPORT>())).bTriggerL as *const _ as usize },
1806 7usize,
1807 concat!(
1808 "Offset of field: ",
1809 stringify!(_DS4_REPORT),
1810 "::",
1811 stringify!(bTriggerL)
1812 )
1813 );
1814 assert_eq!(
1815 unsafe { &(*(::std::ptr::null::<_DS4_REPORT>())).bTriggerR as *const _ as usize },
1816 8usize,
1817 concat!(
1818 "Offset of field: ",
1819 stringify!(_DS4_REPORT),
1820 "::",
1821 stringify!(bTriggerR)
1822 )
1823 );
1824}
1825pub type DS4_REPORT = _DS4_REPORT;
1826#[repr(C)]
1827#[derive(Debug, Copy, Clone)]
1828pub struct _XUSB_REQUEST_NOTIFICATION {
1829 pub Size: ULONG,
1830 pub SerialNo: ULONG,
1831 pub LargeMotor: UCHAR,
1832 pub SmallMotor: UCHAR,
1833 pub LedNumber: UCHAR,
1834}
1835#[test]
1836fn bindgen_test_layout__XUSB_REQUEST_NOTIFICATION() {
1837 assert_eq!(
1838 ::std::mem::size_of::<_XUSB_REQUEST_NOTIFICATION>(),
1839 12usize,
1840 concat!("Size of: ", stringify!(_XUSB_REQUEST_NOTIFICATION))
1841 );
1842 assert_eq!(
1843 ::std::mem::align_of::<_XUSB_REQUEST_NOTIFICATION>(),
1844 4usize,
1845 concat!("Alignment of ", stringify!(_XUSB_REQUEST_NOTIFICATION))
1846 );
1847 assert_eq!(
1848 unsafe { &(*(::std::ptr::null::<_XUSB_REQUEST_NOTIFICATION>())).Size as *const _ as usize },
1849 0usize,
1850 concat!(
1851 "Offset of field: ",
1852 stringify!(_XUSB_REQUEST_NOTIFICATION),
1853 "::",
1854 stringify!(Size)
1855 )
1856 );
1857 assert_eq!(
1858 unsafe {
1859 &(*(::std::ptr::null::<_XUSB_REQUEST_NOTIFICATION>())).SerialNo as *const _ as usize
1860 },
1861 4usize,
1862 concat!(
1863 "Offset of field: ",
1864 stringify!(_XUSB_REQUEST_NOTIFICATION),
1865 "::",
1866 stringify!(SerialNo)
1867 )
1868 );
1869 assert_eq!(
1870 unsafe {
1871 &(*(::std::ptr::null::<_XUSB_REQUEST_NOTIFICATION>())).LargeMotor as *const _ as usize
1872 },
1873 8usize,
1874 concat!(
1875 "Offset of field: ",
1876 stringify!(_XUSB_REQUEST_NOTIFICATION),
1877 "::",
1878 stringify!(LargeMotor)
1879 )
1880 );
1881 assert_eq!(
1882 unsafe {
1883 &(*(::std::ptr::null::<_XUSB_REQUEST_NOTIFICATION>())).SmallMotor as *const _ as usize
1884 },
1885 9usize,
1886 concat!(
1887 "Offset of field: ",
1888 stringify!(_XUSB_REQUEST_NOTIFICATION),
1889 "::",
1890 stringify!(SmallMotor)
1891 )
1892 );
1893 assert_eq!(
1894 unsafe {
1895 &(*(::std::ptr::null::<_XUSB_REQUEST_NOTIFICATION>())).LedNumber as *const _ as usize
1896 },
1897 10usize,
1898 concat!(
1899 "Offset of field: ",
1900 stringify!(_XUSB_REQUEST_NOTIFICATION),
1901 "::",
1902 stringify!(LedNumber)
1903 )
1904 );
1905}
1906#[repr(C)]
1907#[derive(Debug, Copy, Clone)]
1908pub struct _XUSB_SUBMIT_REPORT {
1909 pub Size: ULONG,
1910 pub SerialNo: ULONG,
1911 pub Report: XUSB_REPORT,
1912}
1913#[test]
1914fn bindgen_test_layout__XUSB_SUBMIT_REPORT() {
1915 assert_eq!(
1916 ::std::mem::size_of::<_XUSB_SUBMIT_REPORT>(),
1917 20usize,
1918 concat!("Size of: ", stringify!(_XUSB_SUBMIT_REPORT))
1919 );
1920 assert_eq!(
1921 ::std::mem::align_of::<_XUSB_SUBMIT_REPORT>(),
1922 4usize,
1923 concat!("Alignment of ", stringify!(_XUSB_SUBMIT_REPORT))
1924 );
1925 assert_eq!(
1926 unsafe { &(*(::std::ptr::null::<_XUSB_SUBMIT_REPORT>())).Size as *const _ as usize },
1927 0usize,
1928 concat!(
1929 "Offset of field: ",
1930 stringify!(_XUSB_SUBMIT_REPORT),
1931 "::",
1932 stringify!(Size)
1933 )
1934 );
1935 assert_eq!(
1936 unsafe { &(*(::std::ptr::null::<_XUSB_SUBMIT_REPORT>())).SerialNo as *const _ as usize },
1937 4usize,
1938 concat!(
1939 "Offset of field: ",
1940 stringify!(_XUSB_SUBMIT_REPORT),
1941 "::",
1942 stringify!(SerialNo)
1943 )
1944 );
1945 assert_eq!(
1946 unsafe { &(*(::std::ptr::null::<_XUSB_SUBMIT_REPORT>())).Report as *const _ as usize },
1947 8usize,
1948 concat!(
1949 "Offset of field: ",
1950 stringify!(_XUSB_SUBMIT_REPORT),
1951 "::",
1952 stringify!(Report)
1953 )
1954 );
1955}
1956#[repr(C)]
1957#[derive(Debug, Copy, Clone)]
1958pub struct _XUSB_GET_USER_INDEX {
1959 pub Size: ULONG,
1960 pub SerialNo: ULONG,
1961 pub UserIndex: ULONG,
1962}
1963#[test]
1964fn bindgen_test_layout__XUSB_GET_USER_INDEX() {
1965 assert_eq!(
1966 ::std::mem::size_of::<_XUSB_GET_USER_INDEX>(),
1967 12usize,
1968 concat!("Size of: ", stringify!(_XUSB_GET_USER_INDEX))
1969 );
1970 assert_eq!(
1971 ::std::mem::align_of::<_XUSB_GET_USER_INDEX>(),
1972 4usize,
1973 concat!("Alignment of ", stringify!(_XUSB_GET_USER_INDEX))
1974 );
1975 assert_eq!(
1976 unsafe { &(*(::std::ptr::null::<_XUSB_GET_USER_INDEX>())).Size as *const _ as usize },
1977 0usize,
1978 concat!(
1979 "Offset of field: ",
1980 stringify!(_XUSB_GET_USER_INDEX),
1981 "::",
1982 stringify!(Size)
1983 )
1984 );
1985 assert_eq!(
1986 unsafe { &(*(::std::ptr::null::<_XUSB_GET_USER_INDEX>())).SerialNo as *const _ as usize },
1987 4usize,
1988 concat!(
1989 "Offset of field: ",
1990 stringify!(_XUSB_GET_USER_INDEX),
1991 "::",
1992 stringify!(SerialNo)
1993 )
1994 );
1995 assert_eq!(
1996 unsafe { &(*(::std::ptr::null::<_XUSB_GET_USER_INDEX>())).UserIndex as *const _ as usize },
1997 8usize,
1998 concat!(
1999 "Offset of field: ",
2000 stringify!(_XUSB_GET_USER_INDEX),
2001 "::",
2002 stringify!(UserIndex)
2003 )
2004 );
2005}
2006#[repr(C)]
2007#[derive(Debug, Copy, Clone)]
2008pub struct _DS4_OUTPUT_REPORT {
2009 pub SmallMotor: UCHAR,
2010 pub LargeMotor: UCHAR,
2011 pub LightbarColor: DS4_LIGHTBAR_COLOR,
2012}
2013#[test]
2014fn bindgen_test_layout__DS4_OUTPUT_REPORT() {
2015 assert_eq!(
2016 ::std::mem::size_of::<_DS4_OUTPUT_REPORT>(),
2017 5usize,
2018 concat!("Size of: ", stringify!(_DS4_OUTPUT_REPORT))
2019 );
2020 assert_eq!(
2021 ::std::mem::align_of::<_DS4_OUTPUT_REPORT>(),
2022 1usize,
2023 concat!("Alignment of ", stringify!(_DS4_OUTPUT_REPORT))
2024 );
2025 assert_eq!(
2026 unsafe { &(*(::std::ptr::null::<_DS4_OUTPUT_REPORT>())).SmallMotor as *const _ as usize },
2027 0usize,
2028 concat!(
2029 "Offset of field: ",
2030 stringify!(_DS4_OUTPUT_REPORT),
2031 "::",
2032 stringify!(SmallMotor)
2033 )
2034 );
2035 assert_eq!(
2036 unsafe { &(*(::std::ptr::null::<_DS4_OUTPUT_REPORT>())).LargeMotor as *const _ as usize },
2037 1usize,
2038 concat!(
2039 "Offset of field: ",
2040 stringify!(_DS4_OUTPUT_REPORT),
2041 "::",
2042 stringify!(LargeMotor)
2043 )
2044 );
2045 assert_eq!(
2046 unsafe {
2047 &(*(::std::ptr::null::<_DS4_OUTPUT_REPORT>())).LightbarColor as *const _ as usize
2048 },
2049 2usize,
2050 concat!(
2051 "Offset of field: ",
2052 stringify!(_DS4_OUTPUT_REPORT),
2053 "::",
2054 stringify!(LightbarColor)
2055 )
2056 );
2057}
2058pub type DS4_OUTPUT_REPORT = _DS4_OUTPUT_REPORT;
2059#[repr(C)]
2060#[derive(Debug, Copy, Clone)]
2061pub struct _DS4_REQUEST_NOTIFICATION {
2062 pub Size: ULONG,
2063 pub SerialNo: ULONG,
2064 pub Report: DS4_OUTPUT_REPORT,
2065}
2066#[test]
2067fn bindgen_test_layout__DS4_REQUEST_NOTIFICATION() {
2068 assert_eq!(
2069 ::std::mem::size_of::<_DS4_REQUEST_NOTIFICATION>(),
2070 16usize,
2071 concat!("Size of: ", stringify!(_DS4_REQUEST_NOTIFICATION))
2072 );
2073 assert_eq!(
2074 ::std::mem::align_of::<_DS4_REQUEST_NOTIFICATION>(),
2075 4usize,
2076 concat!("Alignment of ", stringify!(_DS4_REQUEST_NOTIFICATION))
2077 );
2078 assert_eq!(
2079 unsafe { &(*(::std::ptr::null::<_DS4_REQUEST_NOTIFICATION>())).Size as *const _ as usize },
2080 0usize,
2081 concat!(
2082 "Offset of field: ",
2083 stringify!(_DS4_REQUEST_NOTIFICATION),
2084 "::",
2085 stringify!(Size)
2086 )
2087 );
2088 assert_eq!(
2089 unsafe {
2090 &(*(::std::ptr::null::<_DS4_REQUEST_NOTIFICATION>())).SerialNo as *const _ as usize
2091 },
2092 4usize,
2093 concat!(
2094 "Offset of field: ",
2095 stringify!(_DS4_REQUEST_NOTIFICATION),
2096 "::",
2097 stringify!(SerialNo)
2098 )
2099 );
2100 assert_eq!(
2101 unsafe {
2102 &(*(::std::ptr::null::<_DS4_REQUEST_NOTIFICATION>())).Report as *const _ as usize
2103 },
2104 8usize,
2105 concat!(
2106 "Offset of field: ",
2107 stringify!(_DS4_REQUEST_NOTIFICATION),
2108 "::",
2109 stringify!(Report)
2110 )
2111 );
2112}
2113#[repr(C)]
2114#[derive(Debug, Copy, Clone)]
2115pub struct _DS4_SUBMIT_REPORT {
2116 pub Size: ULONG,
2117 pub SerialNo: ULONG,
2118 pub Report: DS4_REPORT,
2119}
2120#[test]
2121fn bindgen_test_layout__DS4_SUBMIT_REPORT() {
2122 assert_eq!(
2123 ::std::mem::size_of::<_DS4_SUBMIT_REPORT>(),
2124 20usize,
2125 concat!("Size of: ", stringify!(_DS4_SUBMIT_REPORT))
2126 );
2127 assert_eq!(
2128 ::std::mem::align_of::<_DS4_SUBMIT_REPORT>(),
2129 4usize,
2130 concat!("Alignment of ", stringify!(_DS4_SUBMIT_REPORT))
2131 );
2132 assert_eq!(
2133 unsafe { &(*(::std::ptr::null::<_DS4_SUBMIT_REPORT>())).Size as *const _ as usize },
2134 0usize,
2135 concat!(
2136 "Offset of field: ",
2137 stringify!(_DS4_SUBMIT_REPORT),
2138 "::",
2139 stringify!(Size)
2140 )
2141 );
2142 assert_eq!(
2143 unsafe { &(*(::std::ptr::null::<_DS4_SUBMIT_REPORT>())).SerialNo as *const _ as usize },
2144 4usize,
2145 concat!(
2146 "Offset of field: ",
2147 stringify!(_DS4_SUBMIT_REPORT),
2148 "::",
2149 stringify!(SerialNo)
2150 )
2151 );
2152 assert_eq!(
2153 unsafe { &(*(::std::ptr::null::<_DS4_SUBMIT_REPORT>())).Report as *const _ as usize },
2154 8usize,
2155 concat!(
2156 "Offset of field: ",
2157 stringify!(_DS4_SUBMIT_REPORT),
2158 "::",
2159 stringify!(Report)
2160 )
2161 );
2162}
2163pub const _VIGEM_ERRORS_VIGEM_ERROR_NONE: _VIGEM_ERRORS = 536870912;
2164pub const _VIGEM_ERRORS_VIGEM_ERROR_BUS_NOT_FOUND: _VIGEM_ERRORS = -536870911;
2165pub const _VIGEM_ERRORS_VIGEM_ERROR_NO_FREE_SLOT: _VIGEM_ERRORS = -536870910;
2166pub const _VIGEM_ERRORS_VIGEM_ERROR_INVALID_TARGET: _VIGEM_ERRORS = -536870909;
2167pub const _VIGEM_ERRORS_VIGEM_ERROR_REMOVAL_FAILED: _VIGEM_ERRORS = -536870908;
2168pub const _VIGEM_ERRORS_VIGEM_ERROR_ALREADY_CONNECTED: _VIGEM_ERRORS = -536870907;
2169pub const _VIGEM_ERRORS_VIGEM_ERROR_TARGET_UNINITIALIZED: _VIGEM_ERRORS = -536870906;
2170pub const _VIGEM_ERRORS_VIGEM_ERROR_TARGET_NOT_PLUGGED_IN: _VIGEM_ERRORS = -536870905;
2171pub const _VIGEM_ERRORS_VIGEM_ERROR_BUS_VERSION_MISMATCH: _VIGEM_ERRORS = -536870904;
2172pub const _VIGEM_ERRORS_VIGEM_ERROR_BUS_ACCESS_FAILED: _VIGEM_ERRORS = -536870903;
2173pub const _VIGEM_ERRORS_VIGEM_ERROR_CALLBACK_ALREADY_REGISTERED: _VIGEM_ERRORS = -536870896;
2174pub const _VIGEM_ERRORS_VIGEM_ERROR_CALLBACK_NOT_FOUND: _VIGEM_ERRORS = -536870895;
2175pub const _VIGEM_ERRORS_VIGEM_ERROR_BUS_ALREADY_CONNECTED: _VIGEM_ERRORS = -536870894;
2176pub const _VIGEM_ERRORS_VIGEM_ERROR_BUS_INVALID_HANDLE: _VIGEM_ERRORS = -536870893;
2177pub const _VIGEM_ERRORS_VIGEM_ERROR_XUSB_USERINDEX_OUT_OF_RANGE: _VIGEM_ERRORS = -536870892;
2178pub const _VIGEM_ERRORS_VIGEM_ERROR_INVALID_PARAMETER: _VIGEM_ERRORS = -536870891;
2179#[doc = " \\typedef enum _VIGEM_ERRORS"]
2180#[doc = ""]
2181#[doc = " \\brief Defines an alias representing the ViGEm errors."]
2182pub type _VIGEM_ERRORS = i32;
2183#[doc = " \\typedef enum _VIGEM_ERRORS"]
2184#[doc = ""]
2185#[doc = " \\brief Defines an alias representing the ViGEm errors."]
2186pub use self::_VIGEM_ERRORS as VIGEM_ERROR;
2187#[doc = " \\typedef struct _VIGEM_CLIENT_T *PVIGEM_CLIENT"]
2188#[doc = ""]
2189#[doc = " \\brief Defines an alias representing a driver connection object."]
2190pub type PVIGEM_CLIENT = *mut _VIGEM_CLIENT_T;
2191#[doc = " \\typedef struct _VIGEM_TARGET_T *PVIGEM_TARGET"]
2192#[doc = ""]
2193#[doc = " \\brief Defines an alias representing a target device object."]
2194pub type PVIGEM_TARGET = *mut _VIGEM_TARGET_T;
2195pub type PFN_VIGEM_TARGET_ADD_RESULT = ::std::option::Option<
2196 unsafe extern "C" fn(arg1: PVIGEM_CLIENT, arg2: PVIGEM_TARGET, arg3: VIGEM_ERROR),
2197>;
2198pub type PFN_VIGEM_X360_NOTIFICATION = ::std::option::Option<
2199 unsafe extern "C" fn(
2200 arg1: PVIGEM_CLIENT,
2201 arg2: PVIGEM_TARGET,
2202 arg3: UCHAR,
2203 arg4: UCHAR,
2204 arg5: UCHAR,
2205 arg6: LPVOID,
2206 ),
2207>;
2208pub type PFN_VIGEM_DS4_NOTIFICATION = ::std::option::Option<
2209 unsafe extern "C" fn(
2210 arg1: PVIGEM_CLIENT,
2211 arg2: PVIGEM_TARGET,
2212 arg3: UCHAR,
2213 arg4: UCHAR,
2214 arg5: DS4_LIGHTBAR_COLOR,
2215 arg6: LPVOID,
2216 ),
2217>;
2218extern "C" {
2219 #[doc = " \\fn PVIGEM_CLIENT vigem_alloc(void);"]
2220 #[doc = ""]
2221 #[doc = " \\brief Allocates an object representing a driver connection."]
2222 #[doc = ""]
2223 #[doc = " \\author Benjamin \"Nefarius\" H\u{fffd}glinger"]
2224 #[doc = " \\date 28.08.2017"]
2225 #[doc = ""]
2226 #[doc = " \\return A new driver connection object."]
2227 pub fn vigem_alloc() -> PVIGEM_CLIENT;
2228}
2229extern "C" {
2230 #[doc = " \\fn void vigem_free(PVIGEM_CLIENT vigem);"]
2231 #[doc = ""]
2232 #[doc = " \\brief Frees up memory used by the driver connection object."]
2233 #[doc = ""]
2234 #[doc = " \\author Benjamin \"Nefarius\" H\u{fffd}glinger"]
2235 #[doc = " \\date 28.08.2017"]
2236 #[doc = ""]
2237 #[doc = " \\param vigem The driver connection object."]
2238 pub fn vigem_free(vigem: PVIGEM_CLIENT);
2239}
2240extern "C" {
2241 #[doc = " \\fn VIGEM_ERROR vigem_connect(PVIGEM_CLIENT vigem);"]
2242 #[doc = ""]
2243 #[doc = " \\brief Initializes the driver object and establishes a connection to the emulation bus"]
2244 #[doc = " driver. Returns an error if no compatible bus device has been found."]
2245 #[doc = ""]
2246 #[doc = " \\author Benjamin \"Nefarius\" H\u{fffd}glinger"]
2247 #[doc = " \\date 28.08.2017"]
2248 #[doc = ""]
2249 #[doc = " \\param vigem The driver connection object."]
2250 #[doc = ""]
2251 #[doc = " \\return A VIGEM_ERROR."]
2252 pub fn vigem_connect(vigem: PVIGEM_CLIENT) -> VIGEM_ERROR;
2253}
2254extern "C" {
2255 #[doc = " \\fn void vigem_disconnect(PVIGEM_CLIENT vigem);"]
2256 #[doc = ""]
2257 #[doc = " \\brief Disconnects from the bus device and resets the driver object state. The driver object"]
2258 #[doc = " may be reused again after calling this function. When called, all targets which may"]
2259 #[doc = " still be connected will be destroyed automatically. Be aware, that allocated target"]
2260 #[doc = " objects won't be automatically freed, this has to be taken care of by the caller."]
2261 #[doc = ""]
2262 #[doc = " \\author Benjamin \"Nefarius\" H\u{fffd}glinger"]
2263 #[doc = " \\date 28.08.2017"]
2264 #[doc = ""]
2265 #[doc = " \\param vigem The driver connection object."]
2266 pub fn vigem_disconnect(vigem: PVIGEM_CLIENT);
2267}
2268extern "C" {
2269 #[doc = " \\fn PVIGEM_TARGET vigem_target_x360_alloc(void);"]
2270 #[doc = ""]
2271 #[doc = " \\brief Allocates an object representing an Xbox 360 Controller device."]
2272 #[doc = ""]
2273 #[doc = " \\author Benjamin \"Nefarius\" H\u{fffd}glinger"]
2274 #[doc = " \\date 28.08.2017"]
2275 #[doc = ""]
2276 #[doc = " \\return A PVIGEM_TARGET representing an Xbox 360 Controller device."]
2277 pub fn vigem_target_x360_alloc() -> PVIGEM_TARGET;
2278}
2279extern "C" {
2280 #[doc = " \\fn PVIGEM_TARGET vigem_target_ds4_alloc(void);"]
2281 #[doc = ""]
2282 #[doc = " \\brief Allocates an object representing a DualShock 4 Controller device."]
2283 #[doc = ""]
2284 #[doc = " \\author Benjamin \"Nefarius\" H\u{fffd}glinger"]
2285 #[doc = " \\date 28.08.2017"]
2286 #[doc = ""]
2287 #[doc = " \\return A PVIGEM_TARGET representing a DualShock 4 Controller device."]
2288 pub fn vigem_target_ds4_alloc() -> PVIGEM_TARGET;
2289}
2290extern "C" {
2291 #[doc = " \\fn void vigem_target_free(PVIGEM_TARGET target);"]
2292 #[doc = ""]
2293 #[doc = " \\brief Frees up memory used by the target device object. This does not automatically remove"]
2294 #[doc = " the associated device from the bus, if present. If the target device doesn't get"]
2295 #[doc = " removed before this call, the device becomes orphaned until the owning process is"]
2296 #[doc = " terminated."]
2297 #[doc = ""]
2298 #[doc = " \\author Benjamin \"Nefarius\" H\u{fffd}glinger"]
2299 #[doc = " \\date 28.08.2017"]
2300 #[doc = ""]
2301 #[doc = " \\param target The target device object."]
2302 pub fn vigem_target_free(target: PVIGEM_TARGET);
2303}
2304extern "C" {
2305 #[doc = " \\fn VIGEM_ERROR vigem_target_add(PVIGEM_CLIENT vigem, PVIGEM_TARGET target);"]
2306 #[doc = ""]
2307 #[doc = " \\brief Adds a provided target device to the bus driver, which is equal to a device plug-in"]
2308 #[doc = " event of a physical hardware device. This function blocks until the target device is"]
2309 #[doc = " in full operational mode."]
2310 #[doc = ""]
2311 #[doc = " \\author Benjamin \"Nefarius\" H\u{fffd}glinger"]
2312 #[doc = " \\date 28.08.2017"]
2313 #[doc = ""]
2314 #[doc = " \\param vigem The driver connection object."]
2315 #[doc = " \\param target The target device object."]
2316 #[doc = ""]
2317 #[doc = " \\return A VIGEM_ERROR."]
2318 pub fn vigem_target_add(vigem: PVIGEM_CLIENT, target: PVIGEM_TARGET) -> VIGEM_ERROR;
2319}
2320extern "C" {
2321 #[doc = " \\fn VIGEM_ERROR vigem_target_add_async(PVIGEM_CLIENT vigem, PVIGEM_TARGET target, PVIGEM_TARGET_ADD_RESULT result);"]
2322 #[doc = ""]
2323 #[doc = " \\brief Adds a provided target device to the bus driver, which is equal to a device plug-in"]
2324 #[doc = " event of a physical hardware device. This function immediately returns. An optional"]
2325 #[doc = " callback may be registered which gets called on error or if the target device has"]
2326 #[doc = " become fully operational."]
2327 #[doc = ""]
2328 #[doc = " \\author Benjamin \"Nefarius\" H\u{fffd}glinger"]
2329 #[doc = " \\date 28.08.2017"]
2330 #[doc = ""]
2331 #[doc = " \\param vigem The driver connection object."]
2332 #[doc = " \\param target The target device object."]
2333 #[doc = " \\param result An optional function getting called when the target device becomes available."]
2334 #[doc = ""]
2335 #[doc = " \\return A VIGEM_ERROR."]
2336 pub fn vigem_target_add_async(
2337 vigem: PVIGEM_CLIENT,
2338 target: PVIGEM_TARGET,
2339 result: PFN_VIGEM_TARGET_ADD_RESULT,
2340 ) -> VIGEM_ERROR;
2341}
2342extern "C" {
2343 #[doc = " \\fn VIGEM_ERROR vigem_target_remove(PVIGEM_CLIENT vigem, PVIGEM_TARGET target);"]
2344 #[doc = ""]
2345 #[doc = " \\brief Removes a provided target device from the bus driver, which is equal to a device"]
2346 #[doc = " unplug event of a physical hardware device. The target device object may be reused"]
2347 #[doc = " after this function is called. If this function is never called on target device"]
2348 #[doc = " objects, they will be removed from the bus when the owning process terminates."]
2349 #[doc = ""]
2350 #[doc = " \\author Benjamin \"Nefarius\" H\u{fffd}glinger"]
2351 #[doc = " \\date 28.08.2017"]
2352 #[doc = ""]
2353 #[doc = " \\param vigem The driver connection object."]
2354 #[doc = " \\param target The target device object."]
2355 #[doc = ""]
2356 #[doc = " \\return A VIGEM_ERROR."]
2357 pub fn vigem_target_remove(vigem: PVIGEM_CLIENT, target: PVIGEM_TARGET) -> VIGEM_ERROR;
2358}
2359extern "C" {
2360 #[doc = " \\fn VIGEM_ERROR vigem_target_x360_register_notification(PVIGEM_CLIENT vigem, PVIGEM_TARGET target, PVIGEM_X360_NOTIFICATION notification);"]
2361 #[doc = ""]
2362 #[doc = " \\brief Registers a function which gets called, when LED index or vibration state changes"]
2363 #[doc = " occur on the provided target device. This function fails if the provided target"]
2364 #[doc = " device isn't fully operational or in an erroneous state."]
2365 #[doc = ""]
2366 #[doc = " \\author Benjamin \"Nefarius\" H\u{fffd}glinger"]
2367 #[doc = " \\date 28.08.2017"]
2368 #[doc = ""]
2369 #[doc = " \\param vigem The driver connection object."]
2370 #[doc = " \\param target The target device object."]
2371 #[doc = " \\param notification The notification callback."]
2372 #[doc = " \\param userData The user data passed to the notification callback."]
2373 #[doc = ""]
2374 #[doc = " \\return A VIGEM_ERROR."]
2375 pub fn vigem_target_x360_register_notification(
2376 vigem: PVIGEM_CLIENT,
2377 target: PVIGEM_TARGET,
2378 notification: PFN_VIGEM_X360_NOTIFICATION,
2379 userData: LPVOID,
2380 ) -> VIGEM_ERROR;
2381}
2382extern "C" {
2383 #[doc = " \\fn VIGEM_ERROR vigem_target_ds4_register_notification(PVIGEM_CLIENT vigem, PVIGEM_TARGET target, PVIGEM_DS4_NOTIFICATION notification);"]
2384 #[doc = ""]
2385 #[doc = " \\brief Registers a function which gets called, when LightBar or vibration state changes"]
2386 #[doc = " occur on the provided target device. This function fails if the provided target"]
2387 #[doc = " device isn't fully operational or in an erroneous state."]
2388 #[doc = ""]
2389 #[doc = " \\author Benjamin \"Nefarius\" H\u{fffd}glinger"]
2390 #[doc = " \\date 28.08.2017"]
2391 #[doc = ""]
2392 #[doc = " \\param vigem The driver connection object."]
2393 #[doc = " \\param target The target device object."]
2394 #[doc = " \\param notification The notification callback."]
2395 #[doc = " \\param userData The user data passed to the notification callback."]
2396 #[doc = ""]
2397 #[doc = " \\return A VIGEM_ERROR."]
2398 pub fn vigem_target_ds4_register_notification(
2399 vigem: PVIGEM_CLIENT,
2400 target: PVIGEM_TARGET,
2401 notification: PFN_VIGEM_DS4_NOTIFICATION,
2402 userData: LPVOID,
2403 ) -> VIGEM_ERROR;
2404}
2405extern "C" {
2406 #[doc = " \\fn void vigem_target_x360_unregister_notification(PVIGEM_TARGET target);"]
2407 #[doc = ""]
2408 #[doc = " \\brief Removes a previously registered callback function from the provided target object."]
2409 #[doc = ""]
2410 #[doc = " \\author Benjamin \"Nefarius\" H\u{fffd}glinger"]
2411 #[doc = " \\date 28.08.2017"]
2412 #[doc = ""]
2413 #[doc = " \\param target The target device object."]
2414 pub fn vigem_target_x360_unregister_notification(target: PVIGEM_TARGET);
2415}
2416extern "C" {
2417 #[doc = " \\fn void vigem_target_ds4_unregister_notification(PVIGEM_TARGET target);"]
2418 #[doc = ""]
2419 #[doc = " \\brief Removes a previously registered callback function from the provided target object."]
2420 #[doc = ""]
2421 #[doc = " \\author Benjamin \"Nefarius\" H\u{fffd}glinger"]
2422 #[doc = " \\date 28.08.2017"]
2423 #[doc = ""]
2424 #[doc = " \\param target The target device object."]
2425 pub fn vigem_target_ds4_unregister_notification(target: PVIGEM_TARGET);
2426}
2427extern "C" {
2428 #[doc = " \\fn void vigem_target_set_vid(PVIGEM_TARGET target, USHORT vid);"]
2429 #[doc = ""]
2430 #[doc = " \\brief Overrides the default Vendor ID value with the provided one."]
2431 #[doc = ""]
2432 #[doc = " \\author Benjamin \"Nefarius\" H\u{fffd}glinger"]
2433 #[doc = " \\date 28.08.2017"]
2434 #[doc = ""]
2435 #[doc = " \\param target The target device object."]
2436 #[doc = " \\param vid The Vendor ID to set."]
2437 pub fn vigem_target_set_vid(target: PVIGEM_TARGET, vid: USHORT);
2438}
2439extern "C" {
2440 #[doc = " \\fn void vigem_target_set_pid(PVIGEM_TARGET target, USHORT pid);"]
2441 #[doc = ""]
2442 #[doc = " \\brief Overrides the default Product ID value with the provided one."]
2443 #[doc = ""]
2444 #[doc = " \\author Benjamin \"Nefarius\" H\u{fffd}glinger"]
2445 #[doc = " \\date 28.08.2017"]
2446 #[doc = ""]
2447 #[doc = " \\param target The target device object."]
2448 #[doc = " \\param pid The Product ID to set."]
2449 pub fn vigem_target_set_pid(target: PVIGEM_TARGET, pid: USHORT);
2450}
2451extern "C" {
2452 #[doc = " \\fn USHORT vigem_target_get_vid(PVIGEM_TARGET target);"]
2453 #[doc = ""]
2454 #[doc = " \\brief Returns the Vendor ID of the provided target device object."]
2455 #[doc = ""]
2456 #[doc = " \\author Benjamin \"Nefarius\" H\u{fffd}glinger"]
2457 #[doc = " \\date 28.08.2017"]
2458 #[doc = ""]
2459 #[doc = " \\param target The target device object."]
2460 #[doc = ""]
2461 #[doc = " \\return The Vendor ID."]
2462 pub fn vigem_target_get_vid(target: PVIGEM_TARGET) -> USHORT;
2463}
2464extern "C" {
2465 #[doc = " \\fn USHORT vigem_target_get_pid(PVIGEM_TARGET target);"]
2466 #[doc = ""]
2467 #[doc = " \\brief Returns the Product ID of the provided target device object."]
2468 #[doc = ""]
2469 #[doc = " \\author Benjamin \"Nefarius\" H\u{fffd}glinger"]
2470 #[doc = " \\date 28.08.2017"]
2471 #[doc = ""]
2472 #[doc = " \\param target The target device object."]
2473 #[doc = ""]
2474 #[doc = " \\return The Product ID."]
2475 pub fn vigem_target_get_pid(target: PVIGEM_TARGET) -> USHORT;
2476}
2477extern "C" {
2478 #[doc = " \\fn VIGEM_ERROR vigem_target_x360_update(PVIGEM_CLIENT vigem, PVIGEM_TARGET target, XUSB_REPORT report);"]
2479 #[doc = ""]
2480 #[doc = " \\brief Sends a state report to the provided target device."]
2481 #[doc = ""]
2482 #[doc = " \\author Benjamin \"Nefarius\" H\u{fffd}glinger"]
2483 #[doc = " \\date 28.08.2017"]
2484 #[doc = ""]
2485 #[doc = " \\param vigem The driver connection object."]
2486 #[doc = " \\param target The target device object."]
2487 #[doc = " \\param report The report to send to the target device."]
2488 #[doc = ""]
2489 #[doc = " \\return A VIGEM_ERROR."]
2490 pub fn vigem_target_x360_update(
2491 vigem: PVIGEM_CLIENT,
2492 target: PVIGEM_TARGET,
2493 report: XUSB_REPORT,
2494 ) -> VIGEM_ERROR;
2495}
2496extern "C" {
2497 #[doc = " \\fn VIGEM_ERROR vigem_target_ds4_update(PVIGEM_CLIENT vigem, PVIGEM_TARGET target, DS4_REPORT report);"]
2498 #[doc = ""]
2499 #[doc = " \\brief Sends a state report to the provided target device."]
2500 #[doc = ""]
2501 #[doc = " \\author Benjamin \"Nefarius\" H\u{fffd}glinger"]
2502 #[doc = " \\date 28.08.2017"]
2503 #[doc = ""]
2504 #[doc = " \\param vigem The driver connection object."]
2505 #[doc = " \\param target The target device object."]
2506 #[doc = " \\param report The report to send to the target device."]
2507 #[doc = ""]
2508 #[doc = " \\return A VIGEM_ERROR."]
2509 pub fn vigem_target_ds4_update(
2510 vigem: PVIGEM_CLIENT,
2511 target: PVIGEM_TARGET,
2512 report: DS4_REPORT,
2513 ) -> VIGEM_ERROR;
2514}
2515extern "C" {
2516 #[doc = " \\fn ULONG vigem_target_get_index(PVIGEM_TARGET target);"]
2517 #[doc = ""]
2518 #[doc = " \\brief Returns the internal index (serial number) the bus driver assigned to the provided"]
2519 #[doc = " target device object. Note that this value is specific to the inner workings of the"]
2520 #[doc = " bus driver, it does not reflect related values like player index or device arrival"]
2521 #[doc = " order experienced by other APIs. It may be used to identify the target device object"]
2522 #[doc = " for its lifetime. This value becomes invalid once the target device is removed from"]
2523 #[doc = " the bus and may change on the next addition of the device."]
2524 #[doc = ""]
2525 #[doc = " \\author Benjamin \"Nefarius\" H\u{fffd}glinger"]
2526 #[doc = " \\date 28.08.2017"]
2527 #[doc = ""]
2528 #[doc = " \\param target The target device object."]
2529 #[doc = ""]
2530 #[doc = " \\return The internally used index of the target device."]
2531 pub fn vigem_target_get_index(target: PVIGEM_TARGET) -> ULONG;
2532}
2533extern "C" {
2534 #[doc = " \\fn VIGEM_TARGET_TYPE vigem_target_get_type(PVIGEM_TARGET target);"]
2535 #[doc = ""]
2536 #[doc = " \\brief Returns the type of the provided target device object."]
2537 #[doc = ""]
2538 #[doc = " \\author Benjamin \"Nefarius\" H\u{fffd}glinger"]
2539 #[doc = " \\date 28.08.2017"]
2540 #[doc = ""]
2541 #[doc = " \\param target The target device object."]
2542 #[doc = ""]
2543 #[doc = " \\return A VIGEM_TARGET_TYPE."]
2544 pub fn vigem_target_get_type(target: PVIGEM_TARGET) -> VIGEM_TARGET_TYPE;
2545}
2546extern "C" {
2547 #[doc = " \\fn BOOL vigem_target_is_attached(PVIGEM_TARGET target);"]
2548 #[doc = ""]
2549 #[doc = " \\brief Returns TRUE if the provided target device object is currently attached to the bus,"]
2550 #[doc = " FALSE otherwise."]
2551 #[doc = ""]
2552 #[doc = " \\author Benjamin \"Nefarius\" H\u{fffd}glinger"]
2553 #[doc = " \\date 30.08.2017"]
2554 #[doc = ""]
2555 #[doc = " \\param target The target device object."]
2556 #[doc = ""]
2557 #[doc = " \\return TRUE if device is attached to the bus, FALSE otherwise."]
2558 pub fn vigem_target_is_attached(target: PVIGEM_TARGET) -> BOOL;
2559}
2560extern "C" {
2561 #[doc = " \\fn VIGEM_API VIGEM_ERROR vigem_target_x360_get_user_index(PVIGEM_CLIENT vigem, PVIGEM_TARGET target, PULONG index);"]
2562 #[doc = ""]
2563 #[doc = " \\brief Returns the user index of the emulated Xenon device. This value correspondents to the"]
2564 #[doc = " (zero-based) index number representing the player number via LED present on a"]
2565 #[doc = " physical controller and is compatible to the dwUserIndex propery of the XInput* APIs."]
2566 #[doc = ""]
2567 #[doc = " \\author Benjamin \"Nefarius\" H\u{fffd}glinger"]
2568 #[doc = " \\date 10.05.2018"]
2569 #[doc = ""]
2570 #[doc = " \\param vigem The driver connection object."]
2571 #[doc = " \\param target The target device object."]
2572 #[doc = " \\param index The (zero-based) user index of the Xenon device."]
2573 #[doc = ""]
2574 #[doc = " \\return A VIGEM_ERROR."]
2575 pub fn vigem_target_x360_get_user_index(
2576 vigem: PVIGEM_CLIENT,
2577 target: PVIGEM_TARGET,
2578 index: PULONG,
2579 ) -> VIGEM_ERROR;
2580}
2581pub type _Thrd_id_t = ::std::os::raw::c_uint;
2582#[repr(C)]
2583#[derive(Debug, Copy, Clone)]
2584pub struct _Thrd_t {
2585 pub _Hnd: *mut ::std::os::raw::c_void,
2586 pub _Id: _Thrd_id_t,
2587}
2588#[test]
2589fn bindgen_test_layout__Thrd_t() {
2590 assert_eq!(
2591 ::std::mem::size_of::<_Thrd_t>(),
2592 16usize,
2593 concat!("Size of: ", stringify!(_Thrd_t))
2594 );
2595 assert_eq!(
2596 ::std::mem::align_of::<_Thrd_t>(),
2597 8usize,
2598 concat!("Alignment of ", stringify!(_Thrd_t))
2599 );
2600 assert_eq!(
2601 unsafe { &(*(::std::ptr::null::<_Thrd_t>()))._Hnd as *const _ as usize },
2602 0usize,
2603 concat!(
2604 "Offset of field: ",
2605 stringify!(_Thrd_t),
2606 "::",
2607 stringify!(_Hnd)
2608 )
2609 );
2610 assert_eq!(
2611 unsafe { &(*(::std::ptr::null::<_Thrd_t>()))._Id as *const _ as usize },
2612 8usize,
2613 concat!(
2614 "Offset of field: ",
2615 stringify!(_Thrd_t),
2616 "::",
2617 stringify!(_Id)
2618 )
2619 );
2620}
2621#[repr(C)]
2622#[derive(Debug, Copy, Clone)]
2623pub struct _VIGEM_CLIENT_T {
2624 pub hBusDevice: HANDLE,
2625}
2626#[test]
2627fn bindgen_test_layout__VIGEM_CLIENT_T() {
2628 assert_eq!(
2629 ::std::mem::size_of::<_VIGEM_CLIENT_T>(),
2630 8usize,
2631 concat!("Size of: ", stringify!(_VIGEM_CLIENT_T))
2632 );
2633 assert_eq!(
2634 ::std::mem::align_of::<_VIGEM_CLIENT_T>(),
2635 8usize,
2636 concat!("Alignment of ", stringify!(_VIGEM_CLIENT_T))
2637 );
2638 assert_eq!(
2639 unsafe { &(*(::std::ptr::null::<_VIGEM_CLIENT_T>())).hBusDevice as *const _ as usize },
2640 0usize,
2641 concat!(
2642 "Offset of field: ",
2643 stringify!(_VIGEM_CLIENT_T),
2644 "::",
2645 stringify!(hBusDevice)
2646 )
2647 );
2648}
2649pub const _VIGEM_TARGET_STATE_VIGEM_TARGET_NEW: _VIGEM_TARGET_STATE = 0;
2650pub const _VIGEM_TARGET_STATE_VIGEM_TARGET_INITIALIZED: _VIGEM_TARGET_STATE = 1;
2651pub const _VIGEM_TARGET_STATE_VIGEM_TARGET_CONNECTED: _VIGEM_TARGET_STATE = 2;
2652pub const _VIGEM_TARGET_STATE_VIGEM_TARGET_DISCONNECTED: _VIGEM_TARGET_STATE = 3;
2653pub type _VIGEM_TARGET_STATE = i32;
2654pub use self::_VIGEM_TARGET_STATE as VIGEM_TARGET_STATE;
2655#[repr(C)]
2656#[derive(Debug)]
2657pub struct _VIGEM_TARGET_T {
2658 pub Size: ULONG,
2659 pub SerialNo: ULONG,
2660 pub State: VIGEM_TARGET_STATE,
2661 pub VendorId: USHORT,
2662 pub ProductId: USHORT,
2663 pub Type: VIGEM_TARGET_TYPE,
2664 pub Notification: FARPROC,
2665 pub NotificationUserData: LPVOID,
2666 pub closingNotificationThreads: bool,
2667 pub cancelNotificationThreadEvent: HANDLE,
2668 pub notificationThreadList: std_unique_ptr,
2669}
2670#[test]
2671fn bindgen_test_layout__VIGEM_TARGET_T() {
2672 assert_eq!(
2673 ::std::mem::size_of::<_VIGEM_TARGET_T>(),
2674 64usize,
2675 concat!("Size of: ", stringify!(_VIGEM_TARGET_T))
2676 );
2677 assert_eq!(
2678 ::std::mem::align_of::<_VIGEM_TARGET_T>(),
2679 8usize,
2680 concat!("Alignment of ", stringify!(_VIGEM_TARGET_T))
2681 );
2682 assert_eq!(
2683 unsafe { &(*(::std::ptr::null::<_VIGEM_TARGET_T>())).Size as *const _ as usize },
2684 0usize,
2685 concat!(
2686 "Offset of field: ",
2687 stringify!(_VIGEM_TARGET_T),
2688 "::",
2689 stringify!(Size)
2690 )
2691 );
2692 assert_eq!(
2693 unsafe { &(*(::std::ptr::null::<_VIGEM_TARGET_T>())).SerialNo as *const _ as usize },
2694 4usize,
2695 concat!(
2696 "Offset of field: ",
2697 stringify!(_VIGEM_TARGET_T),
2698 "::",
2699 stringify!(SerialNo)
2700 )
2701 );
2702 assert_eq!(
2703 unsafe { &(*(::std::ptr::null::<_VIGEM_TARGET_T>())).State as *const _ as usize },
2704 8usize,
2705 concat!(
2706 "Offset of field: ",
2707 stringify!(_VIGEM_TARGET_T),
2708 "::",
2709 stringify!(State)
2710 )
2711 );
2712 assert_eq!(
2713 unsafe { &(*(::std::ptr::null::<_VIGEM_TARGET_T>())).VendorId as *const _ as usize },
2714 12usize,
2715 concat!(
2716 "Offset of field: ",
2717 stringify!(_VIGEM_TARGET_T),
2718 "::",
2719 stringify!(VendorId)
2720 )
2721 );
2722 assert_eq!(
2723 unsafe { &(*(::std::ptr::null::<_VIGEM_TARGET_T>())).ProductId as *const _ as usize },
2724 14usize,
2725 concat!(
2726 "Offset of field: ",
2727 stringify!(_VIGEM_TARGET_T),
2728 "::",
2729 stringify!(ProductId)
2730 )
2731 );
2732 assert_eq!(
2733 unsafe { &(*(::std::ptr::null::<_VIGEM_TARGET_T>())).Type as *const _ as usize },
2734 16usize,
2735 concat!(
2736 "Offset of field: ",
2737 stringify!(_VIGEM_TARGET_T),
2738 "::",
2739 stringify!(Type)
2740 )
2741 );
2742 assert_eq!(
2743 unsafe { &(*(::std::ptr::null::<_VIGEM_TARGET_T>())).Notification as *const _ as usize },
2744 24usize,
2745 concat!(
2746 "Offset of field: ",
2747 stringify!(_VIGEM_TARGET_T),
2748 "::",
2749 stringify!(Notification)
2750 )
2751 );
2752 assert_eq!(
2753 unsafe {
2754 &(*(::std::ptr::null::<_VIGEM_TARGET_T>())).NotificationUserData as *const _ as usize
2755 },
2756 32usize,
2757 concat!(
2758 "Offset of field: ",
2759 stringify!(_VIGEM_TARGET_T),
2760 "::",
2761 stringify!(NotificationUserData)
2762 )
2763 );
2764 assert_eq!(
2765 unsafe {
2766 &(*(::std::ptr::null::<_VIGEM_TARGET_T>())).closingNotificationThreads as *const _
2767 as usize
2768 },
2769 40usize,
2770 concat!(
2771 "Offset of field: ",
2772 stringify!(_VIGEM_TARGET_T),
2773 "::",
2774 stringify!(closingNotificationThreads)
2775 )
2776 );
2777 assert_eq!(
2778 unsafe {
2779 &(*(::std::ptr::null::<_VIGEM_TARGET_T>())).cancelNotificationThreadEvent as *const _
2780 as usize
2781 },
2782 48usize,
2783 concat!(
2784 "Offset of field: ",
2785 stringify!(_VIGEM_TARGET_T),
2786 "::",
2787 stringify!(cancelNotificationThreadEvent)
2788 )
2789 );
2790 assert_eq!(
2791 unsafe {
2792 &(*(::std::ptr::null::<_VIGEM_TARGET_T>())).notificationThreadList as *const _ as usize
2793 },
2794 56usize,
2795 concat!(
2796 "Offset of field: ",
2797 stringify!(_VIGEM_TARGET_T),
2798 "::",
2799 stringify!(notificationThreadList)
2800 )
2801 );
2802}
2803extern "C" {
2804 #[link_name = "\u{1}?vigem_internal_exception_handler@@YAJPEAU_EXCEPTION_POINTERS@@@Z"]
2805 pub fn vigem_internal_exception_handler(apExceptionInfo: *mut _EXCEPTION_POINTERS) -> LONG;
2806}
2807#[repr(C)]
2808pub struct NotificationRequestPayload__bindgen_vtable(::std::os::raw::c_void);
2809#[repr(C)]
2810#[derive(Debug)]
2811pub struct NotificationRequestPayload {
2812 pub vtable_: *const NotificationRequestPayload__bindgen_vtable,
2813 pub lpPayloadBuffer: LPVOID,
2814 pub payloadBufferSize: DWORD,
2815 pub ioControlCode: DWORD,
2816}
2817#[test]
2818fn bindgen_test_layout_NotificationRequestPayload() {
2819 assert_eq!(
2820 ::std::mem::size_of::<NotificationRequestPayload>(),
2821 24usize,
2822 concat!("Size of: ", stringify!(NotificationRequestPayload))
2823 );
2824 assert_eq!(
2825 ::std::mem::align_of::<NotificationRequestPayload>(),
2826 8usize,
2827 concat!("Alignment of ", stringify!(NotificationRequestPayload))
2828 );
2829 assert_eq!(
2830 unsafe {
2831 &(*(::std::ptr::null::<NotificationRequestPayload>())).lpPayloadBuffer as *const _
2832 as usize
2833 },
2834 8usize,
2835 concat!(
2836 "Offset of field: ",
2837 stringify!(NotificationRequestPayload),
2838 "::",
2839 stringify!(lpPayloadBuffer)
2840 )
2841 );
2842 assert_eq!(
2843 unsafe {
2844 &(*(::std::ptr::null::<NotificationRequestPayload>())).payloadBufferSize as *const _
2845 as usize
2846 },
2847 16usize,
2848 concat!(
2849 "Offset of field: ",
2850 stringify!(NotificationRequestPayload),
2851 "::",
2852 stringify!(payloadBufferSize)
2853 )
2854 );
2855 assert_eq!(
2856 unsafe {
2857 &(*(::std::ptr::null::<NotificationRequestPayload>())).ioControlCode as *const _
2858 as usize
2859 },
2860 20usize,
2861 concat!(
2862 "Offset of field: ",
2863 stringify!(NotificationRequestPayload),
2864 "::",
2865 stringify!(ioControlCode)
2866 )
2867 );
2868}
2869extern "C" {
2870 #[link_name = "\u{1}?vigem_notification_thread_worker@@YAXPEAU_VIGEM_CLIENT_T@@PEAU_VIGEM_TARGET_T@@V?$unique_ptr@V?$vector@V?$unique_ptr@VNotificationRequestPayload@@U?$default_delete@VNotificationRequestPayload@@@std@@@std@@V?$allocator@V?$unique_ptr@VNotificationRequestPayload@@U?$default_delete@VNotificationRequestPayload@@@std@@@std@@@2@@std@@U?$default_delete@V?$vector@V?$unique_ptr@VNotificationRequestPayload@@U?$default_delete@VNotificationRequestPayload@@@std@@@std@@V?$allocator@V?$unique_ptr@VNotificationRequestPayload@@U?$default_delete@VNotificationRequestPayload@@@std@@@std@@@2@@std@@@2@@std@@@Z"]
2871 pub fn vigem_notification_thread_worker(
2872 client: PVIGEM_CLIENT,
2873 target: PVIGEM_TARGET,
2874 pNotificationRequestPayload: std_unique_ptr,
2875 );
2876}
2877#[test]
2878fn __bindgen_test_layout_std_unique_ptr_open0_std_vector_open1_std_thread_std_allocator_open2_std_thread_close2_close1_std_default_delete_open1_std_vector_open2_std_thread_std_allocator_open3_std_thread_close3_close2_close1_close0_instantiation(
2879) {
2880 assert_eq!(
2881 ::std::mem::size_of::<std_unique_ptr>(),
2882 8usize,
2883 concat!(
2884 "Size of template specialization: ",
2885 stringify!(std_unique_ptr)
2886 )
2887 );
2888 assert_eq!(
2889 ::std::mem::align_of::<std_unique_ptr>(),
2890 8usize,
2891 concat!(
2892 "Alignment of template specialization: ",
2893 stringify!(std_unique_ptr)
2894 )
2895 );
2896}
2897#[test]
2898fn __bindgen_test_layout_std_vector_open0_std_thread_std_allocator_open1_std_thread_close1_close0_instantiation(
2899) {
2900 assert_eq!(
2901 ::std::mem::size_of::<std_vector>(),
2902 24usize,
2903 concat!("Size of template specialization: ", stringify!(std_vector))
2904 );
2905 assert_eq!(
2906 ::std::mem::align_of::<std_vector>(),
2907 8usize,
2908 concat!(
2909 "Alignment of template specialization: ",
2910 stringify!(std_vector)
2911 )
2912 );
2913}
2914#[test]
2915fn __bindgen_test_layout_std_allocator_open0_std_thread_close0_instantiation() {
2916 assert_eq!(
2917 ::std::mem::size_of::<std_allocator>(),
2918 1usize,
2919 concat!(
2920 "Size of template specialization: ",
2921 stringify!(std_allocator)
2922 )
2923 );
2924 assert_eq!(
2925 ::std::mem::align_of::<std_allocator>(),
2926 1usize,
2927 concat!(
2928 "Alignment of template specialization: ",
2929 stringify!(std_allocator)
2930 )
2931 );
2932}
2933#[test]
2934fn __bindgen_test_layout_std_default_delete_open0_std_vector_open1_std_thread_std_allocator_open2_std_thread_close2_close1_close0_instantiation(
2935) {
2936 assert_eq!(
2937 ::std::mem::size_of::<std_default_delete>(),
2938 1usize,
2939 concat!(
2940 "Size of template specialization: ",
2941 stringify!(std_default_delete)
2942 )
2943 );
2944 assert_eq!(
2945 ::std::mem::align_of::<std_default_delete>(),
2946 1usize,
2947 concat!(
2948 "Alignment of template specialization: ",
2949 stringify!(std_default_delete)
2950 )
2951 );
2952}
2953#[test]
2954fn __bindgen_test_layout_std_vector_open0_std_thread_std_allocator_open1_std_thread_close1_close0_instantiation_1(
2955) {
2956 assert_eq!(
2957 ::std::mem::size_of::<std_vector>(),
2958 24usize,
2959 concat!("Size of template specialization: ", stringify!(std_vector))
2960 );
2961 assert_eq!(
2962 ::std::mem::align_of::<std_vector>(),
2963 8usize,
2964 concat!(
2965 "Alignment of template specialization: ",
2966 stringify!(std_vector)
2967 )
2968 );
2969}
2970#[test]
2971fn __bindgen_test_layout_std_allocator_open0_std_thread_close0_instantiation_1() {
2972 assert_eq!(
2973 ::std::mem::size_of::<std_allocator>(),
2974 1usize,
2975 concat!(
2976 "Size of template specialization: ",
2977 stringify!(std_allocator)
2978 )
2979 );
2980 assert_eq!(
2981 ::std::mem::align_of::<std_allocator>(),
2982 1usize,
2983 concat!(
2984 "Alignment of template specialization: ",
2985 stringify!(std_allocator)
2986 )
2987 );
2988}
2989#[test]
2990fn __bindgen_test_layout_std_unique_ptr_open0_std_vector_open1_std_unique_ptr_open2_NotificationRequestPayload_std_default_delete_open3_NotificationRequestPayload_close3_close2_std_allocator_open2_std_unique_ptr_open3_NotificationRequestPayload_std_default_delete_open4_NotificationRequestPayload_close4_close3_close2_close1_std_default_delete_open1_std_vector_open2_std_unique_ptr_open3_NotificationRequestPayload_std_default_delete_open4_NotificationRequestPayload_close4_close3_std_allocator_open3_std_unique_ptr_open4_NotificationRequestPayload_std_default_delete_open5_NotificationRequestPayload_close5_close4_close3_close2_close1_close0_instantiation(
2991) {
2992 assert_eq!(
2993 ::std::mem::size_of::<std_unique_ptr>(),
2994 8usize,
2995 concat!(
2996 "Size of template specialization: ",
2997 stringify!(std_unique_ptr)
2998 )
2999 );
3000 assert_eq!(
3001 ::std::mem::align_of::<std_unique_ptr>(),
3002 8usize,
3003 concat!(
3004 "Alignment of template specialization: ",
3005 stringify!(std_unique_ptr)
3006 )
3007 );
3008}
3009#[test]
3010fn __bindgen_test_layout_std_vector_open0_std_unique_ptr_open1_NotificationRequestPayload_std_default_delete_open2_NotificationRequestPayload_close2_close1_std_allocator_open1_std_unique_ptr_open2_NotificationRequestPayload_std_default_delete_open3_NotificationRequestPayload_close3_close2_close1_close0_instantiation(
3011) {
3012 assert_eq!(
3013 ::std::mem::size_of::<std_vector>(),
3014 24usize,
3015 concat!("Size of template specialization: ", stringify!(std_vector))
3016 );
3017 assert_eq!(
3018 ::std::mem::align_of::<std_vector>(),
3019 8usize,
3020 concat!(
3021 "Alignment of template specialization: ",
3022 stringify!(std_vector)
3023 )
3024 );
3025}
3026#[test]
3027fn __bindgen_test_layout_std_unique_ptr_open0_NotificationRequestPayload_std_default_delete_open1_NotificationRequestPayload_close1_close0_instantiation(
3028) {
3029 assert_eq!(
3030 ::std::mem::size_of::<std_unique_ptr>(),
3031 8usize,
3032 concat!(
3033 "Size of template specialization: ",
3034 stringify!(std_unique_ptr)
3035 )
3036 );
3037 assert_eq!(
3038 ::std::mem::align_of::<std_unique_ptr>(),
3039 8usize,
3040 concat!(
3041 "Alignment of template specialization: ",
3042 stringify!(std_unique_ptr)
3043 )
3044 );
3045}
3046#[test]
3047fn __bindgen_test_layout_std_default_delete_open0_NotificationRequestPayload_close0_instantiation()
3048{
3049 assert_eq!(
3050 ::std::mem::size_of::<std_default_delete>(),
3051 1usize,
3052 concat!(
3053 "Size of template specialization: ",
3054 stringify!(std_default_delete)
3055 )
3056 );
3057 assert_eq!(
3058 ::std::mem::align_of::<std_default_delete>(),
3059 1usize,
3060 concat!(
3061 "Alignment of template specialization: ",
3062 stringify!(std_default_delete)
3063 )
3064 );
3065}
3066#[test]
3067fn __bindgen_test_layout_std_allocator_open0_std_unique_ptr_open1_NotificationRequestPayload_std_default_delete_open2_NotificationRequestPayload_close2_close1_close0_instantiation(
3068) {
3069 assert_eq!(
3070 ::std::mem::size_of::<std_allocator>(),
3071 1usize,
3072 concat!(
3073 "Size of template specialization: ",
3074 stringify!(std_allocator)
3075 )
3076 );
3077 assert_eq!(
3078 ::std::mem::align_of::<std_allocator>(),
3079 1usize,
3080 concat!(
3081 "Alignment of template specialization: ",
3082 stringify!(std_allocator)
3083 )
3084 );
3085}
3086#[test]
3087fn __bindgen_test_layout_std_unique_ptr_open0_NotificationRequestPayload_std_default_delete_open1_NotificationRequestPayload_close1_close0_instantiation_1(
3088) {
3089 assert_eq!(
3090 ::std::mem::size_of::<std_unique_ptr>(),
3091 8usize,
3092 concat!(
3093 "Size of template specialization: ",
3094 stringify!(std_unique_ptr)
3095 )
3096 );
3097 assert_eq!(
3098 ::std::mem::align_of::<std_unique_ptr>(),
3099 8usize,
3100 concat!(
3101 "Alignment of template specialization: ",
3102 stringify!(std_unique_ptr)
3103 )
3104 );
3105}
3106#[test]
3107fn __bindgen_test_layout_std_default_delete_open0_NotificationRequestPayload_close0_instantiation_1(
3108) {
3109 assert_eq!(
3110 ::std::mem::size_of::<std_default_delete>(),
3111 1usize,
3112 concat!(
3113 "Size of template specialization: ",
3114 stringify!(std_default_delete)
3115 )
3116 );
3117 assert_eq!(
3118 ::std::mem::align_of::<std_default_delete>(),
3119 1usize,
3120 concat!(
3121 "Alignment of template specialization: ",
3122 stringify!(std_default_delete)
3123 )
3124 );
3125}
3126#[test]
3127fn __bindgen_test_layout_std_default_delete_open0_std_vector_open1_std_unique_ptr_open2_NotificationRequestPayload_std_default_delete_open3_NotificationRequestPayload_close3_close2_std_allocator_open2_std_unique_ptr_open3_NotificationRequestPayload_std_default_delete_open4_NotificationRequestPayload_close4_close3_close2_close1_close0_instantiation(
3128) {
3129 assert_eq!(
3130 ::std::mem::size_of::<std_default_delete>(),
3131 1usize,
3132 concat!(
3133 "Size of template specialization: ",
3134 stringify!(std_default_delete)
3135 )
3136 );
3137 assert_eq!(
3138 ::std::mem::align_of::<std_default_delete>(),
3139 1usize,
3140 concat!(
3141 "Alignment of template specialization: ",
3142 stringify!(std_default_delete)
3143 )
3144 );
3145}
3146#[test]
3147fn __bindgen_test_layout_std_vector_open0_std_unique_ptr_open1_NotificationRequestPayload_std_default_delete_open2_NotificationRequestPayload_close2_close1_std_allocator_open1_std_unique_ptr_open2_NotificationRequestPayload_std_default_delete_open3_NotificationRequestPayload_close3_close2_close1_close0_instantiation_1(
3148) {
3149 assert_eq!(
3150 ::std::mem::size_of::<std_vector>(),
3151 24usize,
3152 concat!("Size of template specialization: ", stringify!(std_vector))
3153 );
3154 assert_eq!(
3155 ::std::mem::align_of::<std_vector>(),
3156 8usize,
3157 concat!(
3158 "Alignment of template specialization: ",
3159 stringify!(std_vector)
3160 )
3161 );
3162}
3163#[test]
3164fn __bindgen_test_layout_std_unique_ptr_open0_NotificationRequestPayload_std_default_delete_open1_NotificationRequestPayload_close1_close0_instantiation_2(
3165) {
3166 assert_eq!(
3167 ::std::mem::size_of::<std_unique_ptr>(),
3168 8usize,
3169 concat!(
3170 "Size of template specialization: ",
3171 stringify!(std_unique_ptr)
3172 )
3173 );
3174 assert_eq!(
3175 ::std::mem::align_of::<std_unique_ptr>(),
3176 8usize,
3177 concat!(
3178 "Alignment of template specialization: ",
3179 stringify!(std_unique_ptr)
3180 )
3181 );
3182}
3183#[test]
3184fn __bindgen_test_layout_std_default_delete_open0_NotificationRequestPayload_close0_instantiation_2(
3185) {
3186 assert_eq!(
3187 ::std::mem::size_of::<std_default_delete>(),
3188 1usize,
3189 concat!(
3190 "Size of template specialization: ",
3191 stringify!(std_default_delete)
3192 )
3193 );
3194 assert_eq!(
3195 ::std::mem::align_of::<std_default_delete>(),
3196 1usize,
3197 concat!(
3198 "Alignment of template specialization: ",
3199 stringify!(std_default_delete)
3200 )
3201 );
3202}
3203#[test]
3204fn __bindgen_test_layout_std_allocator_open0_std_unique_ptr_open1_NotificationRequestPayload_std_default_delete_open2_NotificationRequestPayload_close2_close1_close0_instantiation_1(
3205) {
3206 assert_eq!(
3207 ::std::mem::size_of::<std_allocator>(),
3208 1usize,
3209 concat!(
3210 "Size of template specialization: ",
3211 stringify!(std_allocator)
3212 )
3213 );
3214 assert_eq!(
3215 ::std::mem::align_of::<std_allocator>(),
3216 1usize,
3217 concat!(
3218 "Alignment of template specialization: ",
3219 stringify!(std_allocator)
3220 )
3221 );
3222}
3223#[test]
3224fn __bindgen_test_layout_std_unique_ptr_open0_NotificationRequestPayload_std_default_delete_open1_NotificationRequestPayload_close1_close0_instantiation_3(
3225) {
3226 assert_eq!(
3227 ::std::mem::size_of::<std_unique_ptr>(),
3228 8usize,
3229 concat!(
3230 "Size of template specialization: ",
3231 stringify!(std_unique_ptr)
3232 )
3233 );
3234 assert_eq!(
3235 ::std::mem::align_of::<std_unique_ptr>(),
3236 8usize,
3237 concat!(
3238 "Alignment of template specialization: ",
3239 stringify!(std_unique_ptr)
3240 )
3241 );
3242}
3243#[test]
3244fn __bindgen_test_layout_std_default_delete_open0_NotificationRequestPayload_close0_instantiation_3(
3245) {
3246 assert_eq!(
3247 ::std::mem::size_of::<std_default_delete>(),
3248 1usize,
3249 concat!(
3250 "Size of template specialization: ",
3251 stringify!(std_default_delete)
3252 )
3253 );
3254 assert_eq!(
3255 ::std::mem::align_of::<std_default_delete>(),
3256 1usize,
3257 concat!(
3258 "Alignment of template specialization: ",
3259 stringify!(std_default_delete)
3260 )
3261 );
3262}