1 #![allow(
2 dead_code,
3 non_snake_case,
4 non_camel_case_types,
5 non_upper_case_globals
6 )]
7
8 #[repr(C)]
9 #[derive(Copy, Clone)]
10 pub struct rte_ipv4_tuple {
11 pub src_addr: u32,
12 pub dst_addr: u32,
13 pub __bindgen_anon_1: rte_ipv4_tuple__bindgen_ty_1,
14 }
15 #[repr(C)]
16 #[derive(Copy, Clone)]
17 pub union rte_ipv4_tuple__bindgen_ty_1 {
18 pub __bindgen_anon_1: rte_ipv4_tuple__bindgen_ty_1__bindgen_ty_1,
19 pub sctp_tag: u32,
20 }
21 #[repr(C)]
22 #[derive(Debug, Default, Copy, Clone, Hash, PartialEq, Eq)]
23 pub struct rte_ipv4_tuple__bindgen_ty_1__bindgen_ty_1 {
24 pub dport: u16,
25 pub sport: u16,
26 }
27 #[test]
bindgen_test_layout_rte_ipv4_tuple__bindgen_ty_1__bindgen_ty_1()28 fn bindgen_test_layout_rte_ipv4_tuple__bindgen_ty_1__bindgen_ty_1() {
29 const UNINIT: ::std::mem::MaybeUninit<
30 rte_ipv4_tuple__bindgen_ty_1__bindgen_ty_1,
31 > = ::std::mem::MaybeUninit::uninit();
32 let ptr = UNINIT.as_ptr();
33 assert_eq!(
34 ::std::mem::size_of::<rte_ipv4_tuple__bindgen_ty_1__bindgen_ty_1>(),
35 4usize,
36 concat!(
37 "Size of: ",
38 stringify!(rte_ipv4_tuple__bindgen_ty_1__bindgen_ty_1)
39 )
40 );
41 assert_eq!(
42 ::std::mem::align_of::<rte_ipv4_tuple__bindgen_ty_1__bindgen_ty_1>(),
43 2usize,
44 concat!(
45 "Alignment of ",
46 stringify!(rte_ipv4_tuple__bindgen_ty_1__bindgen_ty_1)
47 )
48 );
49 assert_eq!(
50 unsafe { ::std::ptr::addr_of!((*ptr).dport) as usize - ptr as usize },
51 0usize,
52 concat!(
53 "Offset of field: ",
54 stringify!(rte_ipv4_tuple__bindgen_ty_1__bindgen_ty_1),
55 "::",
56 stringify!(dport)
57 )
58 );
59 assert_eq!(
60 unsafe { ::std::ptr::addr_of!((*ptr).sport) as usize - ptr as usize },
61 2usize,
62 concat!(
63 "Offset of field: ",
64 stringify!(rte_ipv4_tuple__bindgen_ty_1__bindgen_ty_1),
65 "::",
66 stringify!(sport)
67 )
68 );
69 }
70 #[test]
bindgen_test_layout_rte_ipv4_tuple__bindgen_ty_1()71 fn bindgen_test_layout_rte_ipv4_tuple__bindgen_ty_1() {
72 const UNINIT: ::std::mem::MaybeUninit<rte_ipv4_tuple__bindgen_ty_1> =
73 ::std::mem::MaybeUninit::uninit();
74 let ptr = UNINIT.as_ptr();
75 assert_eq!(
76 ::std::mem::size_of::<rte_ipv4_tuple__bindgen_ty_1>(),
77 4usize,
78 concat!("Size of: ", stringify!(rte_ipv4_tuple__bindgen_ty_1))
79 );
80 assert_eq!(
81 ::std::mem::align_of::<rte_ipv4_tuple__bindgen_ty_1>(),
82 4usize,
83 concat!("Alignment of ", stringify!(rte_ipv4_tuple__bindgen_ty_1))
84 );
85 assert_eq!(
86 unsafe {
87 ::std::ptr::addr_of!((*ptr).sctp_tag) as usize - ptr as usize
88 },
89 0usize,
90 concat!(
91 "Offset of field: ",
92 stringify!(rte_ipv4_tuple__bindgen_ty_1),
93 "::",
94 stringify!(sctp_tag)
95 )
96 );
97 }
98 impl Default for rte_ipv4_tuple__bindgen_ty_1 {
default() -> Self99 fn default() -> Self {
100 let mut s = ::std::mem::MaybeUninit::<Self>::uninit();
101 unsafe {
102 ::std::ptr::write_bytes(s.as_mut_ptr(), 0, 1);
103 s.assume_init()
104 }
105 }
106 }
107 #[test]
bindgen_test_layout_rte_ipv4_tuple()108 fn bindgen_test_layout_rte_ipv4_tuple() {
109 const UNINIT: ::std::mem::MaybeUninit<rte_ipv4_tuple> =
110 ::std::mem::MaybeUninit::uninit();
111 let ptr = UNINIT.as_ptr();
112 assert_eq!(
113 ::std::mem::size_of::<rte_ipv4_tuple>(),
114 12usize,
115 concat!("Size of: ", stringify!(rte_ipv4_tuple))
116 );
117 assert_eq!(
118 ::std::mem::align_of::<rte_ipv4_tuple>(),
119 4usize,
120 concat!("Alignment of ", stringify!(rte_ipv4_tuple))
121 );
122 assert_eq!(
123 unsafe {
124 ::std::ptr::addr_of!((*ptr).src_addr) as usize - ptr as usize
125 },
126 0usize,
127 concat!(
128 "Offset of field: ",
129 stringify!(rte_ipv4_tuple),
130 "::",
131 stringify!(src_addr)
132 )
133 );
134 assert_eq!(
135 unsafe {
136 ::std::ptr::addr_of!((*ptr).dst_addr) as usize - ptr as usize
137 },
138 4usize,
139 concat!(
140 "Offset of field: ",
141 stringify!(rte_ipv4_tuple),
142 "::",
143 stringify!(dst_addr)
144 )
145 );
146 }
147 impl Default for rte_ipv4_tuple {
default() -> Self148 fn default() -> Self {
149 let mut s = ::std::mem::MaybeUninit::<Self>::uninit();
150 unsafe {
151 ::std::ptr::write_bytes(s.as_mut_ptr(), 0, 1);
152 s.assume_init()
153 }
154 }
155 }
156 #[repr(C)]
157 #[derive(Copy, Clone)]
158 pub struct rte_ipv6_tuple {
159 pub src_addr: [u8; 16usize],
160 pub dst_addr: [u8; 16usize],
161 pub __bindgen_anon_1: rte_ipv6_tuple__bindgen_ty_1,
162 }
163 #[repr(C)]
164 #[derive(Copy, Clone)]
165 pub union rte_ipv6_tuple__bindgen_ty_1 {
166 pub __bindgen_anon_1: rte_ipv6_tuple__bindgen_ty_1__bindgen_ty_1,
167 pub sctp_tag: u32,
168 }
169 #[repr(C)]
170 #[derive(Debug, Default, Copy, Clone, Hash, PartialEq, Eq)]
171 pub struct rte_ipv6_tuple__bindgen_ty_1__bindgen_ty_1 {
172 pub dport: u16,
173 pub sport: u16,
174 }
175 #[test]
bindgen_test_layout_rte_ipv6_tuple__bindgen_ty_1__bindgen_ty_1()176 fn bindgen_test_layout_rte_ipv6_tuple__bindgen_ty_1__bindgen_ty_1() {
177 const UNINIT: ::std::mem::MaybeUninit<
178 rte_ipv6_tuple__bindgen_ty_1__bindgen_ty_1,
179 > = ::std::mem::MaybeUninit::uninit();
180 let ptr = UNINIT.as_ptr();
181 assert_eq!(
182 ::std::mem::size_of::<rte_ipv6_tuple__bindgen_ty_1__bindgen_ty_1>(),
183 4usize,
184 concat!(
185 "Size of: ",
186 stringify!(rte_ipv6_tuple__bindgen_ty_1__bindgen_ty_1)
187 )
188 );
189 assert_eq!(
190 ::std::mem::align_of::<rte_ipv6_tuple__bindgen_ty_1__bindgen_ty_1>(),
191 2usize,
192 concat!(
193 "Alignment of ",
194 stringify!(rte_ipv6_tuple__bindgen_ty_1__bindgen_ty_1)
195 )
196 );
197 assert_eq!(
198 unsafe { ::std::ptr::addr_of!((*ptr).dport) as usize - ptr as usize },
199 0usize,
200 concat!(
201 "Offset of field: ",
202 stringify!(rte_ipv6_tuple__bindgen_ty_1__bindgen_ty_1),
203 "::",
204 stringify!(dport)
205 )
206 );
207 assert_eq!(
208 unsafe { ::std::ptr::addr_of!((*ptr).sport) as usize - ptr as usize },
209 2usize,
210 concat!(
211 "Offset of field: ",
212 stringify!(rte_ipv6_tuple__bindgen_ty_1__bindgen_ty_1),
213 "::",
214 stringify!(sport)
215 )
216 );
217 }
218 #[test]
bindgen_test_layout_rte_ipv6_tuple__bindgen_ty_1()219 fn bindgen_test_layout_rte_ipv6_tuple__bindgen_ty_1() {
220 const UNINIT: ::std::mem::MaybeUninit<rte_ipv6_tuple__bindgen_ty_1> =
221 ::std::mem::MaybeUninit::uninit();
222 let ptr = UNINIT.as_ptr();
223 assert_eq!(
224 ::std::mem::size_of::<rte_ipv6_tuple__bindgen_ty_1>(),
225 4usize,
226 concat!("Size of: ", stringify!(rte_ipv6_tuple__bindgen_ty_1))
227 );
228 assert_eq!(
229 ::std::mem::align_of::<rte_ipv6_tuple__bindgen_ty_1>(),
230 4usize,
231 concat!("Alignment of ", stringify!(rte_ipv6_tuple__bindgen_ty_1))
232 );
233 assert_eq!(
234 unsafe {
235 ::std::ptr::addr_of!((*ptr).sctp_tag) as usize - ptr as usize
236 },
237 0usize,
238 concat!(
239 "Offset of field: ",
240 stringify!(rte_ipv6_tuple__bindgen_ty_1),
241 "::",
242 stringify!(sctp_tag)
243 )
244 );
245 }
246 impl Default for rte_ipv6_tuple__bindgen_ty_1 {
default() -> Self247 fn default() -> Self {
248 let mut s = ::std::mem::MaybeUninit::<Self>::uninit();
249 unsafe {
250 ::std::ptr::write_bytes(s.as_mut_ptr(), 0, 1);
251 s.assume_init()
252 }
253 }
254 }
255 #[test]
bindgen_test_layout_rte_ipv6_tuple()256 fn bindgen_test_layout_rte_ipv6_tuple() {
257 const UNINIT: ::std::mem::MaybeUninit<rte_ipv6_tuple> =
258 ::std::mem::MaybeUninit::uninit();
259 let ptr = UNINIT.as_ptr();
260 assert_eq!(
261 ::std::mem::size_of::<rte_ipv6_tuple>(),
262 36usize,
263 concat!("Size of: ", stringify!(rte_ipv6_tuple))
264 );
265 assert_eq!(
266 ::std::mem::align_of::<rte_ipv6_tuple>(),
267 4usize,
268 concat!("Alignment of ", stringify!(rte_ipv6_tuple))
269 );
270 assert_eq!(
271 unsafe {
272 ::std::ptr::addr_of!((*ptr).src_addr) as usize - ptr as usize
273 },
274 0usize,
275 concat!(
276 "Offset of field: ",
277 stringify!(rte_ipv6_tuple),
278 "::",
279 stringify!(src_addr)
280 )
281 );
282 assert_eq!(
283 unsafe {
284 ::std::ptr::addr_of!((*ptr).dst_addr) as usize - ptr as usize
285 },
286 16usize,
287 concat!(
288 "Offset of field: ",
289 stringify!(rte_ipv6_tuple),
290 "::",
291 stringify!(dst_addr)
292 )
293 );
294 }
295 impl Default for rte_ipv6_tuple {
default() -> Self296 fn default() -> Self {
297 let mut s = ::std::mem::MaybeUninit::<Self>::uninit();
298 unsafe {
299 ::std::ptr::write_bytes(s.as_mut_ptr(), 0, 1);
300 s.assume_init()
301 }
302 }
303 }
304 #[repr(C)]
305 #[repr(align(16))]
306 #[derive(Copy, Clone)]
307 pub union rte_thash_tuple {
308 pub v4: rte_ipv4_tuple,
309 pub v6: rte_ipv6_tuple,
310 }
311 #[test]
bindgen_test_layout_rte_thash_tuple()312 fn bindgen_test_layout_rte_thash_tuple() {
313 const UNINIT: ::std::mem::MaybeUninit<rte_thash_tuple> =
314 ::std::mem::MaybeUninit::uninit();
315 let ptr = UNINIT.as_ptr();
316 assert_eq!(
317 ::std::mem::size_of::<rte_thash_tuple>(),
318 48usize,
319 concat!("Size of: ", stringify!(rte_thash_tuple))
320 );
321 assert_eq!(
322 ::std::mem::align_of::<rte_thash_tuple>(),
323 16usize,
324 concat!("Alignment of ", stringify!(rte_thash_tuple))
325 );
326 assert_eq!(
327 unsafe { ::std::ptr::addr_of!((*ptr).v4) as usize - ptr as usize },
328 0usize,
329 concat!(
330 "Offset of field: ",
331 stringify!(rte_thash_tuple),
332 "::",
333 stringify!(v4)
334 )
335 );
336 assert_eq!(
337 unsafe { ::std::ptr::addr_of!((*ptr).v6) as usize - ptr as usize },
338 0usize,
339 concat!(
340 "Offset of field: ",
341 stringify!(rte_thash_tuple),
342 "::",
343 stringify!(v6)
344 )
345 );
346 }
347 impl Default for rte_thash_tuple {
default() -> Self348 fn default() -> Self {
349 let mut s = ::std::mem::MaybeUninit::<Self>::uninit();
350 unsafe {
351 ::std::ptr::write_bytes(s.as_mut_ptr(), 0, 1);
352 s.assume_init()
353 }
354 }
355 }
356