1use super::class_requires::*;
2use super::*;
3#[allow(non_upper_case_globals, non_snake_case)]
10#[cfg_attr(feature = "json_schema", derive(schemars::JsonSchema))]
11#[cfg_attr(feature = "serde", derive(serde::Serialize, serde::Deserialize))]
12#[derive(educe::Educe)]
13#[educe(Debug, Clone, Default, PartialEq)]
14pub struct hkTrackerSerializableScanSnapshotBlock {
15 #[cfg_attr(
22 feature = "serde",
23 serde(skip_serializing_if = "Option::is_none", default)
24 )]
25 pub __ptr: Option<Pointer>,
26 #[cfg_attr(feature = "json_schema", schemars(rename = "typeIndex"))]
31 #[cfg_attr(feature = "serde", serde(rename = "typeIndex"))]
32 pub m_typeIndex: i32,
33 #[cfg_attr(feature = "json_schema", schemars(rename = "start"))]
38 #[cfg_attr(feature = "serde", serde(rename = "start"))]
39 pub m_start: Ulong,
40 #[cfg_attr(feature = "json_schema", schemars(rename = "size"))]
45 #[cfg_attr(feature = "serde", serde(rename = "size"))]
46 pub m_size: Ulong,
47 #[cfg_attr(feature = "json_schema", schemars(rename = "arraySize"))]
52 #[cfg_attr(feature = "serde", serde(rename = "arraySize"))]
53 pub m_arraySize: i32,
54 #[cfg_attr(feature = "json_schema", schemars(rename = "startReferenceIndex"))]
59 #[cfg_attr(feature = "serde", serde(rename = "startReferenceIndex"))]
60 pub m_startReferenceIndex: i32,
61 #[cfg_attr(feature = "json_schema", schemars(rename = "numReferences"))]
66 #[cfg_attr(feature = "serde", serde(rename = "numReferences"))]
67 pub m_numReferences: i32,
68}
69const _: () = {
70 use havok_serde as _serde;
71 impl _serde::HavokClass for hkTrackerSerializableScanSnapshotBlock {
72 #[inline]
73 fn name(&self) -> &'static str {
74 "hkTrackerSerializableScanSnapshotBlock"
75 }
76 #[inline]
77 fn signature(&self) -> _serde::__private::Signature {
78 _serde::__private::Signature::new(0xe7f23e6d)
79 }
80 #[allow(clippy::let_and_return, clippy::vec_init_then_push)]
81 fn deps_indexes(&self) -> Vec<usize> {
82 let mut v = Vec::new();
83 v
84 }
85 }
86 impl _serde::Serialize for hkTrackerSerializableScanSnapshotBlock {
87 fn serialize<S>(&self, __serializer: S) -> Result<S::Ok, S::Error>
88 where
89 S: _serde::ser::Serializer,
90 {
91 let class_meta = self
92 .__ptr
93 .map(|name| (name, _serde::__private::Signature::new(0xe7f23e6d)));
94 let mut serializer = __serializer
95 .serialize_struct(
96 "hkTrackerSerializableScanSnapshotBlock",
97 class_meta,
98 (24u64, 40u64),
99 )?;
100 serializer.serialize_field("typeIndex", &self.m_typeIndex)?;
101 serializer.pad_field([0u8; 0usize].as_slice(), [0u8; 4usize].as_slice())?;
102 serializer.serialize_field("start", &self.m_start)?;
103 serializer.serialize_field("size", &self.m_size)?;
104 serializer.serialize_field("arraySize", &self.m_arraySize)?;
105 serializer
106 .serialize_field("startReferenceIndex", &self.m_startReferenceIndex)?;
107 serializer.serialize_field("numReferences", &self.m_numReferences)?;
108 serializer.pad_field([0u8; 0usize].as_slice(), [0u8; 4usize].as_slice())?;
109 serializer.end()
110 }
111 }
112};
113#[doc(hidden)]
114#[allow(non_upper_case_globals, unused_attributes, unused_qualifications)]
115const _: () = {
116 use havok_serde as _serde;
117 #[automatically_derived]
118 impl<'de> _serde::Deserialize<'de> for hkTrackerSerializableScanSnapshotBlock {
119 fn deserialize<__D>(deserializer: __D) -> core::result::Result<Self, __D::Error>
120 where
121 __D: _serde::Deserializer<'de>,
122 {
123 #[allow(non_camel_case_types)]
124 enum __Field {
125 m_typeIndex,
126 m_start,
127 m_size,
128 m_arraySize,
129 m_startReferenceIndex,
130 m_numReferences,
131 __ignore,
132 }
133 struct __FieldVisitor;
134 impl<'de> _serde::de::Visitor<'de> for __FieldVisitor {
135 type Value = __Field;
136 fn expecting(
137 &self,
138 __formatter: &mut core::fmt::Formatter,
139 ) -> core::fmt::Result {
140 core::fmt::Formatter::write_str(__formatter, "field identifier")
141 }
142 #[allow(clippy::match_single_binding)]
144 #[allow(clippy::reversed_empty_ranges)]
145 #[allow(clippy::single_match)]
146 fn visit_key<__E>(
147 self,
148 __value: &str,
149 ) -> core::result::Result<Self::Value, __E>
150 where
151 __E: _serde::de::Error,
152 {
153 match __value {
154 "typeIndex" => Ok(__Field::m_typeIndex),
155 "start" => Ok(__Field::m_start),
156 "size" => Ok(__Field::m_size),
157 "arraySize" => Ok(__Field::m_arraySize),
158 "startReferenceIndex" => Ok(__Field::m_startReferenceIndex),
159 "numReferences" => Ok(__Field::m_numReferences),
160 _ => Ok(__Field::__ignore),
161 }
162 }
163 }
164 impl<'de> _serde::Deserialize<'de> for __Field {
165 #[inline]
166 fn deserialize<__D>(
167 __deserializer: __D,
168 ) -> core::result::Result<Self, __D::Error>
169 where
170 __D: _serde::Deserializer<'de>,
171 {
172 _serde::Deserializer::deserialize_key(__deserializer, __FieldVisitor)
173 }
174 }
175 struct __hkTrackerSerializableScanSnapshotBlockVisitor<'de> {
176 marker: _serde::__private::PhantomData<
177 hkTrackerSerializableScanSnapshotBlock,
178 >,
179 lifetime: _serde::__private::PhantomData<&'de ()>,
180 }
181 #[allow(clippy::match_single_binding)]
182 #[allow(clippy::reversed_empty_ranges)]
183 #[allow(clippy::single_match)]
184 impl<'de> _serde::de::Visitor<'de>
185 for __hkTrackerSerializableScanSnapshotBlockVisitor<'de> {
186 type Value = hkTrackerSerializableScanSnapshotBlock;
187 fn expecting(
188 &self,
189 __formatter: &mut core::fmt::Formatter,
190 ) -> core::fmt::Result {
191 core::fmt::Formatter::write_str(
192 __formatter,
193 "struct hkTrackerSerializableScanSnapshotBlock",
194 )
195 }
196 fn visit_struct_for_bytes<__A>(
197 self,
198 mut __map: __A,
199 ) -> _serde::__private::Result<Self::Value, __A::Error>
200 where
201 __A: _serde::de::MapAccess<'de>,
202 {
203 let __ptr = __A::class_ptr(&mut __map);
204 let mut m_typeIndex: _serde::__private::Option<i32> = _serde::__private::None;
205 let mut m_start: _serde::__private::Option<Ulong> = _serde::__private::None;
206 let mut m_size: _serde::__private::Option<Ulong> = _serde::__private::None;
207 let mut m_arraySize: _serde::__private::Option<i32> = _serde::__private::None;
208 let mut m_startReferenceIndex: _serde::__private::Option<i32> = _serde::__private::None;
209 let mut m_numReferences: _serde::__private::Option<i32> = _serde::__private::None;
210 for i in 0..6usize {
211 match i {
212 0usize => {
213 if _serde::__private::Option::is_some(&m_typeIndex) {
214 return _serde::__private::Err(
215 <__A::Error as _serde::de::Error>::duplicate_field(
216 "typeIndex",
217 ),
218 );
219 }
220 m_typeIndex = _serde::__private::Some(
221 match __A::next_value::<i32>(&mut __map) {
222 _serde::__private::Ok(__val) => __val,
223 _serde::__private::Err(__err) => {
224 return _serde::__private::Err(__err);
225 }
226 },
227 );
228 }
229 1usize => {
230 if _serde::__private::Option::is_some(&m_start) {
231 return _serde::__private::Err(
232 <__A::Error as _serde::de::Error>::duplicate_field("start"),
233 );
234 }
235 __A::pad(&mut __map, 0usize, 4usize)?;
236 m_start = _serde::__private::Some(
237 match __A::next_value::<Ulong>(&mut __map) {
238 _serde::__private::Ok(__val) => __val,
239 _serde::__private::Err(__err) => {
240 return _serde::__private::Err(__err);
241 }
242 },
243 );
244 }
245 2usize => {
246 if _serde::__private::Option::is_some(&m_size) {
247 return _serde::__private::Err(
248 <__A::Error as _serde::de::Error>::duplicate_field("size"),
249 );
250 }
251 m_size = _serde::__private::Some(
252 match __A::next_value::<Ulong>(&mut __map) {
253 _serde::__private::Ok(__val) => __val,
254 _serde::__private::Err(__err) => {
255 return _serde::__private::Err(__err);
256 }
257 },
258 );
259 }
260 3usize => {
261 if _serde::__private::Option::is_some(&m_arraySize) {
262 return _serde::__private::Err(
263 <__A::Error as _serde::de::Error>::duplicate_field(
264 "arraySize",
265 ),
266 );
267 }
268 m_arraySize = _serde::__private::Some(
269 match __A::next_value::<i32>(&mut __map) {
270 _serde::__private::Ok(__val) => __val,
271 _serde::__private::Err(__err) => {
272 return _serde::__private::Err(__err);
273 }
274 },
275 );
276 }
277 4usize => {
278 if _serde::__private::Option::is_some(
279 &m_startReferenceIndex,
280 ) {
281 return _serde::__private::Err(
282 <__A::Error as _serde::de::Error>::duplicate_field(
283 "startReferenceIndex",
284 ),
285 );
286 }
287 m_startReferenceIndex = _serde::__private::Some(
288 match __A::next_value::<i32>(&mut __map) {
289 _serde::__private::Ok(__val) => __val,
290 _serde::__private::Err(__err) => {
291 return _serde::__private::Err(__err);
292 }
293 },
294 );
295 }
296 5usize => {
297 if _serde::__private::Option::is_some(&m_numReferences) {
298 return _serde::__private::Err(
299 <__A::Error as _serde::de::Error>::duplicate_field(
300 "numReferences",
301 ),
302 );
303 }
304 m_numReferences = _serde::__private::Some(
305 match __A::next_value::<i32>(&mut __map) {
306 _serde::__private::Ok(__val) => __val,
307 _serde::__private::Err(__err) => {
308 return _serde::__private::Err(__err);
309 }
310 },
311 );
312 }
313 _ => {}
314 }
315 }
316 __A::pad(&mut __map, 0usize, 4usize)?;
317 let m_typeIndex = match m_typeIndex {
318 _serde::__private::Some(__field) => __field,
319 _serde::__private::None => {
320 return _serde::__private::Err(
321 <__A::Error as _serde::de::Error>::missing_field(
322 "typeIndex",
323 ),
324 );
325 }
326 };
327 let m_start = match m_start {
328 _serde::__private::Some(__field) => __field,
329 _serde::__private::None => {
330 return _serde::__private::Err(
331 <__A::Error as _serde::de::Error>::missing_field("start"),
332 );
333 }
334 };
335 let m_size = match m_size {
336 _serde::__private::Some(__field) => __field,
337 _serde::__private::None => {
338 return _serde::__private::Err(
339 <__A::Error as _serde::de::Error>::missing_field("size"),
340 );
341 }
342 };
343 let m_arraySize = match m_arraySize {
344 _serde::__private::Some(__field) => __field,
345 _serde::__private::None => {
346 return _serde::__private::Err(
347 <__A::Error as _serde::de::Error>::missing_field(
348 "arraySize",
349 ),
350 );
351 }
352 };
353 let m_startReferenceIndex = match m_startReferenceIndex {
354 _serde::__private::Some(__field) => __field,
355 _serde::__private::None => {
356 return _serde::__private::Err(
357 <__A::Error as _serde::de::Error>::missing_field(
358 "startReferenceIndex",
359 ),
360 );
361 }
362 };
363 let m_numReferences = match m_numReferences {
364 _serde::__private::Some(__field) => __field,
365 _serde::__private::None => {
366 return _serde::__private::Err(
367 <__A::Error as _serde::de::Error>::missing_field(
368 "numReferences",
369 ),
370 );
371 }
372 };
373 _serde::__private::Ok(hkTrackerSerializableScanSnapshotBlock {
374 __ptr,
375 m_typeIndex,
376 m_start,
377 m_size,
378 m_arraySize,
379 m_startReferenceIndex,
380 m_numReferences,
381 })
382 }
383 #[allow(clippy::manual_unwrap_or_default)]
384 fn visit_struct<__A>(
385 self,
386 mut __map: __A,
387 ) -> _serde::__private::Result<Self::Value, __A::Error>
388 where
389 __A: _serde::de::MapAccess<'de>,
390 {
391 let mut m_typeIndex: _serde::__private::Option<i32> = _serde::__private::None;
392 let mut m_start: _serde::__private::Option<Ulong> = _serde::__private::None;
393 let mut m_size: _serde::__private::Option<Ulong> = _serde::__private::None;
394 let mut m_arraySize: _serde::__private::Option<i32> = _serde::__private::None;
395 let mut m_startReferenceIndex: _serde::__private::Option<i32> = _serde::__private::None;
396 let mut m_numReferences: _serde::__private::Option<i32> = _serde::__private::None;
397 while let _serde::__private::Some(__key) = {
398 __A::next_key::<__Field>(&mut __map)?
399 } {
400 match __key {
401 __Field::m_typeIndex => {
402 #[cfg(
403 any(feature = "strict", feature = "ignore_duplicates")
404 )]
405 if _serde::__private::Option::is_some(&m_typeIndex) {
406 #[cfg(feature = "ignore_duplicates")]
407 {
408 __A::skip_value(&mut __map)?;
409 continue;
410 }
411 #[cfg(feature = "strict")]
412 return _serde::__private::Err(
413 <__A::Error as _serde::de::Error>::duplicate_field(
414 "typeIndex",
415 ),
416 );
417 }
418 m_typeIndex = _serde::__private::Some(
419 match __A::next_value::<i32>(&mut __map) {
420 _serde::__private::Ok(__val) => __val,
421 _serde::__private::Err(__err) => {
422 return _serde::__private::Err(__err);
423 }
424 },
425 );
426 }
427 __Field::m_start => {
428 #[cfg(
429 any(feature = "strict", feature = "ignore_duplicates")
430 )]
431 if _serde::__private::Option::is_some(&m_start) {
432 #[cfg(feature = "ignore_duplicates")]
433 {
434 __A::skip_value(&mut __map)?;
435 continue;
436 }
437 #[cfg(feature = "strict")]
438 return _serde::__private::Err(
439 <__A::Error as _serde::de::Error>::duplicate_field("start"),
440 );
441 }
442 m_start = _serde::__private::Some(
443 match __A::next_value::<Ulong>(&mut __map) {
444 _serde::__private::Ok(__val) => __val,
445 _serde::__private::Err(__err) => {
446 return _serde::__private::Err(__err);
447 }
448 },
449 );
450 }
451 __Field::m_size => {
452 #[cfg(
453 any(feature = "strict", feature = "ignore_duplicates")
454 )]
455 if _serde::__private::Option::is_some(&m_size) {
456 #[cfg(feature = "ignore_duplicates")]
457 {
458 __A::skip_value(&mut __map)?;
459 continue;
460 }
461 #[cfg(feature = "strict")]
462 return _serde::__private::Err(
463 <__A::Error as _serde::de::Error>::duplicate_field("size"),
464 );
465 }
466 m_size = _serde::__private::Some(
467 match __A::next_value::<Ulong>(&mut __map) {
468 _serde::__private::Ok(__val) => __val,
469 _serde::__private::Err(__err) => {
470 return _serde::__private::Err(__err);
471 }
472 },
473 );
474 }
475 __Field::m_arraySize => {
476 #[cfg(
477 any(feature = "strict", feature = "ignore_duplicates")
478 )]
479 if _serde::__private::Option::is_some(&m_arraySize) {
480 #[cfg(feature = "ignore_duplicates")]
481 {
482 __A::skip_value(&mut __map)?;
483 continue;
484 }
485 #[cfg(feature = "strict")]
486 return _serde::__private::Err(
487 <__A::Error as _serde::de::Error>::duplicate_field(
488 "arraySize",
489 ),
490 );
491 }
492 m_arraySize = _serde::__private::Some(
493 match __A::next_value::<i32>(&mut __map) {
494 _serde::__private::Ok(__val) => __val,
495 _serde::__private::Err(__err) => {
496 return _serde::__private::Err(__err);
497 }
498 },
499 );
500 }
501 __Field::m_startReferenceIndex => {
502 #[cfg(
503 any(feature = "strict", feature = "ignore_duplicates")
504 )]
505 if _serde::__private::Option::is_some(
506 &m_startReferenceIndex,
507 ) {
508 #[cfg(feature = "ignore_duplicates")]
509 {
510 __A::skip_value(&mut __map)?;
511 continue;
512 }
513 #[cfg(feature = "strict")]
514 return _serde::__private::Err(
515 <__A::Error as _serde::de::Error>::duplicate_field(
516 "startReferenceIndex",
517 ),
518 );
519 }
520 m_startReferenceIndex = _serde::__private::Some(
521 match __A::next_value::<i32>(&mut __map) {
522 _serde::__private::Ok(__val) => __val,
523 _serde::__private::Err(__err) => {
524 return _serde::__private::Err(__err);
525 }
526 },
527 );
528 }
529 __Field::m_numReferences => {
530 #[cfg(
531 any(feature = "strict", feature = "ignore_duplicates")
532 )]
533 if _serde::__private::Option::is_some(&m_numReferences) {
534 #[cfg(feature = "ignore_duplicates")]
535 {
536 __A::skip_value(&mut __map)?;
537 continue;
538 }
539 #[cfg(feature = "strict")]
540 return _serde::__private::Err(
541 <__A::Error as _serde::de::Error>::duplicate_field(
542 "numReferences",
543 ),
544 );
545 }
546 m_numReferences = _serde::__private::Some(
547 match __A::next_value::<i32>(&mut __map) {
548 _serde::__private::Ok(__val) => __val,
549 _serde::__private::Err(__err) => {
550 return _serde::__private::Err(__err);
551 }
552 },
553 );
554 }
555 _ => __A::skip_value(&mut __map)?,
556 }
557 }
558 let m_typeIndex = match m_typeIndex {
559 _serde::__private::Some(__field) => __field,
560 _serde::__private::None => {
561 #[cfg(feature = "strict")]
562 return _serde::__private::Err(
563 <__A::Error as _serde::de::Error>::missing_field(
564 "typeIndex",
565 ),
566 );
567 #[cfg(not(feature = "strict"))] Default::default()
568 }
569 };
570 let m_start = match m_start {
571 _serde::__private::Some(__field) => __field,
572 _serde::__private::None => {
573 #[cfg(feature = "strict")]
574 return _serde::__private::Err(
575 <__A::Error as _serde::de::Error>::missing_field("start"),
576 );
577 #[cfg(not(feature = "strict"))] Default::default()
578 }
579 };
580 let m_size = match m_size {
581 _serde::__private::Some(__field) => __field,
582 _serde::__private::None => {
583 #[cfg(feature = "strict")]
584 return _serde::__private::Err(
585 <__A::Error as _serde::de::Error>::missing_field("size"),
586 );
587 #[cfg(not(feature = "strict"))] Default::default()
588 }
589 };
590 let m_arraySize = match m_arraySize {
591 _serde::__private::Some(__field) => __field,
592 _serde::__private::None => {
593 #[cfg(feature = "strict")]
594 return _serde::__private::Err(
595 <__A::Error as _serde::de::Error>::missing_field(
596 "arraySize",
597 ),
598 );
599 #[cfg(not(feature = "strict"))] Default::default()
600 }
601 };
602 let m_startReferenceIndex = match m_startReferenceIndex {
603 _serde::__private::Some(__field) => __field,
604 _serde::__private::None => {
605 #[cfg(feature = "strict")]
606 return _serde::__private::Err(
607 <__A::Error as _serde::de::Error>::missing_field(
608 "startReferenceIndex",
609 ),
610 );
611 #[cfg(not(feature = "strict"))] Default::default()
612 }
613 };
614 let m_numReferences = match m_numReferences {
615 _serde::__private::Some(__field) => __field,
616 _serde::__private::None => {
617 #[cfg(feature = "strict")]
618 return _serde::__private::Err(
619 <__A::Error as _serde::de::Error>::missing_field(
620 "numReferences",
621 ),
622 );
623 #[cfg(not(feature = "strict"))] Default::default()
624 }
625 };
626 let __ptr = __A::class_ptr(&mut __map);
627 _serde::__private::Ok(hkTrackerSerializableScanSnapshotBlock {
628 __ptr,
629 m_typeIndex,
630 m_start,
631 m_size,
632 m_arraySize,
633 m_startReferenceIndex,
634 m_numReferences,
635 })
636 }
637 }
638 const FIELDS: &[&str] = &[
639 "typeIndex",
640 "start",
641 "size",
642 "arraySize",
643 "startReferenceIndex",
644 "numReferences",
645 ];
646 _serde::Deserializer::deserialize_struct(
647 deserializer,
648 "hkTrackerSerializableScanSnapshotBlock",
649 FIELDS,
650 __hkTrackerSerializableScanSnapshotBlockVisitor {
651 marker: _serde::__private::PhantomData::<
652 hkTrackerSerializableScanSnapshotBlock,
653 >,
654 lifetime: _serde::__private::PhantomData,
655 },
656 )
657 }
658 }
659};