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 hkClass<'a> {
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 = "serde", serde(borrow))]
31 #[cfg_attr(feature = "json_schema", schemars(rename = "name"))]
32 #[cfg_attr(feature = "serde", serde(rename = "name"))]
33 pub m_name: CString<'a>,
34 #[cfg_attr(feature = "json_schema", schemars(rename = "parent"))]
39 #[cfg_attr(feature = "serde", serde(rename = "parent"))]
40 pub m_parent: Pointer,
41 #[cfg_attr(feature = "json_schema", schemars(rename = "objectSize"))]
46 #[cfg_attr(feature = "serde", serde(rename = "objectSize"))]
47 pub m_objectSize: i32,
48 #[cfg_attr(feature = "json_schema", schemars(rename = "numImplementedInterfaces"))]
53 #[cfg_attr(feature = "serde", serde(rename = "numImplementedInterfaces"))]
54 pub m_numImplementedInterfaces: i32,
55 #[cfg_attr(feature = "serde", serde(borrow))]
60 #[cfg_attr(feature = "json_schema", schemars(rename = "declaredEnums"))]
61 #[cfg_attr(feature = "serde", serde(rename = "declaredEnums"))]
62 pub m_declaredEnums: Vec<hkClassEnum<'a>>,
63 #[cfg_attr(feature = "serde", serde(borrow))]
68 #[cfg_attr(feature = "json_schema", schemars(rename = "declaredMembers"))]
69 #[cfg_attr(feature = "serde", serde(rename = "declaredMembers"))]
70 pub m_declaredMembers: Vec<hkClassMember<'a>>,
71 #[cfg_attr(feature = "json_schema", schemars(rename = "defaults"))]
77 #[cfg_attr(feature = "serde", serde(rename = "defaults"))]
78 pub m_defaults: Pointer,
79 #[cfg_attr(feature = "json_schema", schemars(rename = "attributes"))]
85 #[cfg_attr(feature = "serde", serde(rename = "attributes"))]
86 pub m_attributes: Pointer,
87 #[cfg_attr(feature = "json_schema", schemars(rename = "flags"))]
92 #[cfg_attr(feature = "serde", serde(rename = "flags"))]
93 pub m_flags: FlagValues,
94 #[cfg_attr(feature = "json_schema", schemars(rename = "describedVersion"))]
99 #[cfg_attr(feature = "serde", serde(rename = "describedVersion"))]
100 pub m_describedVersion: i32,
101}
102const _: () = {
103 use havok_serde as _serde;
104 impl<'a> _serde::HavokClass for hkClass<'a> {
105 #[inline]
106 fn name(&self) -> &'static str {
107 "hkClass"
108 }
109 #[inline]
110 fn signature(&self) -> _serde::__private::Signature {
111 _serde::__private::Signature::new(0x75585ef6)
112 }
113 #[allow(clippy::let_and_return, clippy::vec_init_then_push)]
114 fn deps_indexes(&self) -> Vec<usize> {
115 let mut v = Vec::new();
116 v.push(self.m_parent.get());
117 v.push(self.m_defaults.get());
118 v.push(self.m_attributes.get());
119 v
120 }
121 }
122 impl<'a> _serde::Serialize for hkClass<'a> {
123 fn serialize<S>(&self, __serializer: S) -> Result<S::Ok, S::Error>
124 where
125 S: _serde::ser::Serializer,
126 {
127 let class_meta = self
128 .__ptr
129 .map(|name| (name, _serde::__private::Signature::new(0x75585ef6)));
130 let mut serializer = __serializer
131 .serialize_struct("hkClass", class_meta, (48u64, 80u64))?;
132 serializer.serialize_field("name", &self.m_name)?;
133 serializer.serialize_field("parent", &self.m_parent)?;
134 serializer.serialize_field("objectSize", &self.m_objectSize)?;
135 serializer
136 .serialize_field(
137 "numImplementedInterfaces",
138 &self.m_numImplementedInterfaces,
139 )?;
140 serializer.serialize_field("declaredEnums", &self.m_declaredEnums)?;
141 serializer.pad_field([0u8; 0usize].as_slice(), [0u8; 4usize].as_slice())?;
142 serializer.serialize_field("declaredMembers", &self.m_declaredMembers)?;
143 serializer.pad_field([0u8; 0usize].as_slice(), [0u8; 4usize].as_slice())?;
144 serializer.skip_field("defaults", &self.m_defaults)?;
145 serializer.skip_field("attributes", &self.m_attributes)?;
146 serializer.serialize_field("flags", &self.m_flags)?;
147 serializer.serialize_field("describedVersion", &self.m_describedVersion)?;
148 serializer.end()
149 }
150 }
151};
152#[doc(hidden)]
153#[allow(non_upper_case_globals, unused_attributes, unused_qualifications)]
154const _: () = {
155 use havok_serde as _serde;
156 #[automatically_derived]
157 impl<'de> _serde::Deserialize<'de> for hkClass<'de> {
158 fn deserialize<__D>(deserializer: __D) -> core::result::Result<Self, __D::Error>
159 where
160 __D: _serde::Deserializer<'de>,
161 {
162 #[allow(non_camel_case_types)]
163 enum __Field {
164 m_name,
165 m_parent,
166 m_objectSize,
167 m_numImplementedInterfaces,
168 m_declaredEnums,
169 m_declaredMembers,
170 m_flags,
171 m_describedVersion,
172 __ignore,
173 }
174 struct __FieldVisitor;
175 impl<'de> _serde::de::Visitor<'de> for __FieldVisitor {
176 type Value = __Field;
177 fn expecting(
178 &self,
179 __formatter: &mut core::fmt::Formatter,
180 ) -> core::fmt::Result {
181 core::fmt::Formatter::write_str(__formatter, "field identifier")
182 }
183 #[allow(clippy::match_single_binding)]
185 #[allow(clippy::reversed_empty_ranges)]
186 #[allow(clippy::single_match)]
187 fn visit_key<__E>(
188 self,
189 __value: &str,
190 ) -> core::result::Result<Self::Value, __E>
191 where
192 __E: _serde::de::Error,
193 {
194 match __value {
195 "name" => Ok(__Field::m_name),
196 "parent" => Ok(__Field::m_parent),
197 "objectSize" => Ok(__Field::m_objectSize),
198 "numImplementedInterfaces" => {
199 Ok(__Field::m_numImplementedInterfaces)
200 }
201 "declaredEnums" => Ok(__Field::m_declaredEnums),
202 "declaredMembers" => Ok(__Field::m_declaredMembers),
203 "flags" => Ok(__Field::m_flags),
204 "describedVersion" => Ok(__Field::m_describedVersion),
205 _ => Ok(__Field::__ignore),
206 }
207 }
208 }
209 impl<'de> _serde::Deserialize<'de> for __Field {
210 #[inline]
211 fn deserialize<__D>(
212 __deserializer: __D,
213 ) -> core::result::Result<Self, __D::Error>
214 where
215 __D: _serde::Deserializer<'de>,
216 {
217 _serde::Deserializer::deserialize_key(__deserializer, __FieldVisitor)
218 }
219 }
220 struct __hkClassVisitor<'de> {
221 marker: _serde::__private::PhantomData<hkClass<'de>>,
222 lifetime: _serde::__private::PhantomData<&'de ()>,
223 }
224 #[allow(clippy::match_single_binding)]
225 #[allow(clippy::reversed_empty_ranges)]
226 #[allow(clippy::single_match)]
227 impl<'de> _serde::de::Visitor<'de> for __hkClassVisitor<'de> {
228 type Value = hkClass<'de>;
229 fn expecting(
230 &self,
231 __formatter: &mut core::fmt::Formatter,
232 ) -> core::fmt::Result {
233 core::fmt::Formatter::write_str(__formatter, "struct hkClass")
234 }
235 fn visit_struct_for_bytes<__A>(
236 self,
237 mut __map: __A,
238 ) -> _serde::__private::Result<Self::Value, __A::Error>
239 where
240 __A: _serde::de::MapAccess<'de>,
241 {
242 let __ptr = __A::class_ptr(&mut __map);
243 let mut m_name: _serde::__private::Option<CString<'de>> = _serde::__private::None;
244 let mut m_parent: _serde::__private::Option<Pointer> = _serde::__private::None;
245 let mut m_objectSize: _serde::__private::Option<i32> = _serde::__private::None;
246 let mut m_numImplementedInterfaces: _serde::__private::Option<i32> = _serde::__private::None;
247 let mut m_declaredEnums: _serde::__private::Option<
248 Vec<hkClassEnum<'de>>,
249 > = _serde::__private::None;
250 let mut m_declaredMembers: _serde::__private::Option<
251 Vec<hkClassMember<'de>>,
252 > = _serde::__private::None;
253 let mut m_defaults: _serde::__private::Option<Pointer> = _serde::__private::None;
254 let mut m_attributes: _serde::__private::Option<Pointer> = _serde::__private::None;
255 let mut m_flags: _serde::__private::Option<FlagValues> = _serde::__private::None;
256 let mut m_describedVersion: _serde::__private::Option<i32> = _serde::__private::None;
257 for i in 0..10usize {
258 match i {
259 0usize => {
260 if _serde::__private::Option::is_some(&m_name) {
261 return _serde::__private::Err(
262 <__A::Error as _serde::de::Error>::duplicate_field("name"),
263 );
264 }
265 m_name = _serde::__private::Some(
266 match __A::next_value::<CString<'de>>(&mut __map) {
267 _serde::__private::Ok(__val) => __val,
268 _serde::__private::Err(__err) => {
269 return _serde::__private::Err(__err);
270 }
271 },
272 );
273 }
274 1usize => {
275 if _serde::__private::Option::is_some(&m_parent) {
276 return _serde::__private::Err(
277 <__A::Error as _serde::de::Error>::duplicate_field("parent"),
278 );
279 }
280 m_parent = _serde::__private::Some(
281 match __A::next_value::<Pointer>(&mut __map) {
282 _serde::__private::Ok(__val) => __val,
283 _serde::__private::Err(__err) => {
284 return _serde::__private::Err(__err);
285 }
286 },
287 );
288 }
289 2usize => {
290 if _serde::__private::Option::is_some(&m_objectSize) {
291 return _serde::__private::Err(
292 <__A::Error as _serde::de::Error>::duplicate_field(
293 "objectSize",
294 ),
295 );
296 }
297 m_objectSize = _serde::__private::Some(
298 match __A::next_value::<i32>(&mut __map) {
299 _serde::__private::Ok(__val) => __val,
300 _serde::__private::Err(__err) => {
301 return _serde::__private::Err(__err);
302 }
303 },
304 );
305 }
306 3usize => {
307 if _serde::__private::Option::is_some(
308 &m_numImplementedInterfaces,
309 ) {
310 return _serde::__private::Err(
311 <__A::Error as _serde::de::Error>::duplicate_field(
312 "numImplementedInterfaces",
313 ),
314 );
315 }
316 m_numImplementedInterfaces = _serde::__private::Some(
317 match __A::next_value::<i32>(&mut __map) {
318 _serde::__private::Ok(__val) => __val,
319 _serde::__private::Err(__err) => {
320 return _serde::__private::Err(__err);
321 }
322 },
323 );
324 }
325 4usize => {
326 if _serde::__private::Option::is_some(&m_declaredEnums) {
327 return _serde::__private::Err(
328 <__A::Error as _serde::de::Error>::duplicate_field(
329 "declaredEnums",
330 ),
331 );
332 }
333 m_declaredEnums = _serde::__private::Some(
334 match __A::next_value::<Vec<hkClassEnum<'de>>>(&mut __map) {
335 _serde::__private::Ok(__val) => __val,
336 _serde::__private::Err(__err) => {
337 return _serde::__private::Err(__err);
338 }
339 },
340 );
341 }
342 5usize => {
343 if _serde::__private::Option::is_some(&m_declaredMembers) {
344 return _serde::__private::Err(
345 <__A::Error as _serde::de::Error>::duplicate_field(
346 "declaredMembers",
347 ),
348 );
349 }
350 __A::pad(&mut __map, 0usize, 4usize)?;
351 m_declaredMembers = _serde::__private::Some(
352 match __A::next_value::<
353 Vec<hkClassMember<'de>>,
354 >(&mut __map) {
355 _serde::__private::Ok(__val) => __val,
356 _serde::__private::Err(__err) => {
357 return _serde::__private::Err(__err);
358 }
359 },
360 );
361 }
362 6usize => {
363 if _serde::__private::Option::is_some(&m_defaults) {
364 return _serde::__private::Err(
365 <__A::Error as _serde::de::Error>::duplicate_field(
366 "defaults",
367 ),
368 );
369 }
370 __A::pad(&mut __map, 0usize, 4usize)?;
371 m_defaults = _serde::__private::Some(
372 match __A::next_value::<Pointer>(&mut __map) {
373 _serde::__private::Ok(__val) => __val,
374 _serde::__private::Err(__err) => {
375 return _serde::__private::Err(__err);
376 }
377 },
378 );
379 }
380 7usize => {
381 if _serde::__private::Option::is_some(&m_attributes) {
382 return _serde::__private::Err(
383 <__A::Error as _serde::de::Error>::duplicate_field(
384 "attributes",
385 ),
386 );
387 }
388 m_attributes = _serde::__private::Some(
389 match __A::next_value::<Pointer>(&mut __map) {
390 _serde::__private::Ok(__val) => __val,
391 _serde::__private::Err(__err) => {
392 return _serde::__private::Err(__err);
393 }
394 },
395 );
396 }
397 8usize => {
398 if _serde::__private::Option::is_some(&m_flags) {
399 return _serde::__private::Err(
400 <__A::Error as _serde::de::Error>::duplicate_field("flags"),
401 );
402 }
403 m_flags = _serde::__private::Some(
404 match __A::next_value::<FlagValues>(&mut __map) {
405 _serde::__private::Ok(__val) => __val,
406 _serde::__private::Err(__err) => {
407 return _serde::__private::Err(__err);
408 }
409 },
410 );
411 }
412 9usize => {
413 if _serde::__private::Option::is_some(&m_describedVersion) {
414 return _serde::__private::Err(
415 <__A::Error as _serde::de::Error>::duplicate_field(
416 "describedVersion",
417 ),
418 );
419 }
420 m_describedVersion = _serde::__private::Some(
421 match __A::next_value::<i32>(&mut __map) {
422 _serde::__private::Ok(__val) => __val,
423 _serde::__private::Err(__err) => {
424 return _serde::__private::Err(__err);
425 }
426 },
427 );
428 }
429 _ => {}
430 }
431 }
432 let m_name = match m_name {
433 _serde::__private::Some(__field) => __field,
434 _serde::__private::None => {
435 return _serde::__private::Err(
436 <__A::Error as _serde::de::Error>::missing_field("name"),
437 );
438 }
439 };
440 let m_parent = match m_parent {
441 _serde::__private::Some(__field) => __field,
442 _serde::__private::None => {
443 return _serde::__private::Err(
444 <__A::Error as _serde::de::Error>::missing_field("parent"),
445 );
446 }
447 };
448 let m_objectSize = match m_objectSize {
449 _serde::__private::Some(__field) => __field,
450 _serde::__private::None => {
451 return _serde::__private::Err(
452 <__A::Error as _serde::de::Error>::missing_field(
453 "objectSize",
454 ),
455 );
456 }
457 };
458 let m_numImplementedInterfaces = match m_numImplementedInterfaces {
459 _serde::__private::Some(__field) => __field,
460 _serde::__private::None => {
461 return _serde::__private::Err(
462 <__A::Error as _serde::de::Error>::missing_field(
463 "numImplementedInterfaces",
464 ),
465 );
466 }
467 };
468 let m_declaredEnums = match m_declaredEnums {
469 _serde::__private::Some(__field) => __field,
470 _serde::__private::None => {
471 return _serde::__private::Err(
472 <__A::Error as _serde::de::Error>::missing_field(
473 "declaredEnums",
474 ),
475 );
476 }
477 };
478 let m_declaredMembers = match m_declaredMembers {
479 _serde::__private::Some(__field) => __field,
480 _serde::__private::None => {
481 return _serde::__private::Err(
482 <__A::Error as _serde::de::Error>::missing_field(
483 "declaredMembers",
484 ),
485 );
486 }
487 };
488 let m_defaults = match m_defaults {
489 _serde::__private::Some(__field) => __field,
490 _serde::__private::None => {
491 return _serde::__private::Err(
492 <__A::Error as _serde::de::Error>::missing_field("defaults"),
493 );
494 }
495 };
496 let m_attributes = match m_attributes {
497 _serde::__private::Some(__field) => __field,
498 _serde::__private::None => {
499 return _serde::__private::Err(
500 <__A::Error as _serde::de::Error>::missing_field(
501 "attributes",
502 ),
503 );
504 }
505 };
506 let m_flags = match m_flags {
507 _serde::__private::Some(__field) => __field,
508 _serde::__private::None => {
509 return _serde::__private::Err(
510 <__A::Error as _serde::de::Error>::missing_field("flags"),
511 );
512 }
513 };
514 let m_describedVersion = match m_describedVersion {
515 _serde::__private::Some(__field) => __field,
516 _serde::__private::None => {
517 return _serde::__private::Err(
518 <__A::Error as _serde::de::Error>::missing_field(
519 "describedVersion",
520 ),
521 );
522 }
523 };
524 _serde::__private::Ok(hkClass {
525 __ptr,
526 m_name,
527 m_parent,
528 m_objectSize,
529 m_numImplementedInterfaces,
530 m_declaredEnums,
531 m_declaredMembers,
532 m_defaults,
533 m_attributes,
534 m_flags,
535 m_describedVersion,
536 })
537 }
538 #[allow(clippy::manual_unwrap_or_default)]
539 fn visit_struct<__A>(
540 self,
541 mut __map: __A,
542 ) -> _serde::__private::Result<Self::Value, __A::Error>
543 where
544 __A: _serde::de::MapAccess<'de>,
545 {
546 let mut m_name: _serde::__private::Option<CString<'de>> = _serde::__private::None;
547 let mut m_parent: _serde::__private::Option<Pointer> = _serde::__private::None;
548 let mut m_objectSize: _serde::__private::Option<i32> = _serde::__private::None;
549 let mut m_numImplementedInterfaces: _serde::__private::Option<i32> = _serde::__private::None;
550 let mut m_declaredEnums: _serde::__private::Option<
551 Vec<hkClassEnum<'de>>,
552 > = _serde::__private::None;
553 let mut m_declaredMembers: _serde::__private::Option<
554 Vec<hkClassMember<'de>>,
555 > = _serde::__private::None;
556 let mut m_flags: _serde::__private::Option<FlagValues> = _serde::__private::None;
557 let mut m_describedVersion: _serde::__private::Option<i32> = _serde::__private::None;
558 while let _serde::__private::Some(__key) = {
559 __A::next_key::<__Field>(&mut __map)?
560 } {
561 match __key {
562 __Field::m_name => {
563 #[cfg(
564 any(feature = "strict", feature = "ignore_duplicates")
565 )]
566 if _serde::__private::Option::is_some(&m_name) {
567 #[cfg(feature = "ignore_duplicates")]
568 {
569 __A::skip_value(&mut __map)?;
570 continue;
571 }
572 #[cfg(feature = "strict")]
573 return _serde::__private::Err(
574 <__A::Error as _serde::de::Error>::duplicate_field("name"),
575 );
576 }
577 m_name = _serde::__private::Some(
578 match __A::next_value::<CString<'de>>(&mut __map) {
579 _serde::__private::Ok(__val) => __val,
580 _serde::__private::Err(__err) => {
581 return _serde::__private::Err(__err);
582 }
583 },
584 );
585 }
586 __Field::m_parent => {
587 #[cfg(
588 any(feature = "strict", feature = "ignore_duplicates")
589 )]
590 if _serde::__private::Option::is_some(&m_parent) {
591 #[cfg(feature = "ignore_duplicates")]
592 {
593 __A::skip_value(&mut __map)?;
594 continue;
595 }
596 #[cfg(feature = "strict")]
597 return _serde::__private::Err(
598 <__A::Error as _serde::de::Error>::duplicate_field("parent"),
599 );
600 }
601 m_parent = _serde::__private::Some(
602 match __A::next_value::<Pointer>(&mut __map) {
603 _serde::__private::Ok(__val) => __val,
604 _serde::__private::Err(__err) => {
605 return _serde::__private::Err(__err);
606 }
607 },
608 );
609 }
610 __Field::m_objectSize => {
611 #[cfg(
612 any(feature = "strict", feature = "ignore_duplicates")
613 )]
614 if _serde::__private::Option::is_some(&m_objectSize) {
615 #[cfg(feature = "ignore_duplicates")]
616 {
617 __A::skip_value(&mut __map)?;
618 continue;
619 }
620 #[cfg(feature = "strict")]
621 return _serde::__private::Err(
622 <__A::Error as _serde::de::Error>::duplicate_field(
623 "objectSize",
624 ),
625 );
626 }
627 m_objectSize = _serde::__private::Some(
628 match __A::next_value::<i32>(&mut __map) {
629 _serde::__private::Ok(__val) => __val,
630 _serde::__private::Err(__err) => {
631 return _serde::__private::Err(__err);
632 }
633 },
634 );
635 }
636 __Field::m_numImplementedInterfaces => {
637 #[cfg(
638 any(feature = "strict", feature = "ignore_duplicates")
639 )]
640 if _serde::__private::Option::is_some(
641 &m_numImplementedInterfaces,
642 ) {
643 #[cfg(feature = "ignore_duplicates")]
644 {
645 __A::skip_value(&mut __map)?;
646 continue;
647 }
648 #[cfg(feature = "strict")]
649 return _serde::__private::Err(
650 <__A::Error as _serde::de::Error>::duplicate_field(
651 "numImplementedInterfaces",
652 ),
653 );
654 }
655 m_numImplementedInterfaces = _serde::__private::Some(
656 match __A::next_value::<i32>(&mut __map) {
657 _serde::__private::Ok(__val) => __val,
658 _serde::__private::Err(__err) => {
659 return _serde::__private::Err(__err);
660 }
661 },
662 );
663 }
664 __Field::m_declaredEnums => {
665 #[cfg(
666 any(feature = "strict", feature = "ignore_duplicates")
667 )]
668 if _serde::__private::Option::is_some(&m_declaredEnums) {
669 #[cfg(feature = "ignore_duplicates")]
670 {
671 __A::skip_value(&mut __map)?;
672 continue;
673 }
674 #[cfg(feature = "strict")]
675 return _serde::__private::Err(
676 <__A::Error as _serde::de::Error>::duplicate_field(
677 "declaredEnums",
678 ),
679 );
680 }
681 m_declaredEnums = _serde::__private::Some(
682 match __A::next_value::<Vec<hkClassEnum<'de>>>(&mut __map) {
683 _serde::__private::Ok(__val) => __val,
684 _serde::__private::Err(__err) => {
685 return _serde::__private::Err(__err);
686 }
687 },
688 );
689 }
690 __Field::m_declaredMembers => {
691 #[cfg(
692 any(feature = "strict", feature = "ignore_duplicates")
693 )]
694 if _serde::__private::Option::is_some(&m_declaredMembers) {
695 #[cfg(feature = "ignore_duplicates")]
696 {
697 __A::skip_value(&mut __map)?;
698 continue;
699 }
700 #[cfg(feature = "strict")]
701 return _serde::__private::Err(
702 <__A::Error as _serde::de::Error>::duplicate_field(
703 "declaredMembers",
704 ),
705 );
706 }
707 m_declaredMembers = _serde::__private::Some(
708 match __A::next_value::<
709 Vec<hkClassMember<'de>>,
710 >(&mut __map) {
711 _serde::__private::Ok(__val) => __val,
712 _serde::__private::Err(__err) => {
713 return _serde::__private::Err(__err);
714 }
715 },
716 );
717 }
718 __Field::m_flags => {
719 #[cfg(
720 any(feature = "strict", feature = "ignore_duplicates")
721 )]
722 if _serde::__private::Option::is_some(&m_flags) {
723 #[cfg(feature = "ignore_duplicates")]
724 {
725 __A::skip_value(&mut __map)?;
726 continue;
727 }
728 #[cfg(feature = "strict")]
729 return _serde::__private::Err(
730 <__A::Error as _serde::de::Error>::duplicate_field("flags"),
731 );
732 }
733 m_flags = _serde::__private::Some(
734 match __A::next_value::<FlagValues>(&mut __map) {
735 _serde::__private::Ok(__val) => __val,
736 _serde::__private::Err(__err) => {
737 return _serde::__private::Err(__err);
738 }
739 },
740 );
741 }
742 __Field::m_describedVersion => {
743 #[cfg(
744 any(feature = "strict", feature = "ignore_duplicates")
745 )]
746 if _serde::__private::Option::is_some(&m_describedVersion) {
747 #[cfg(feature = "ignore_duplicates")]
748 {
749 __A::skip_value(&mut __map)?;
750 continue;
751 }
752 #[cfg(feature = "strict")]
753 return _serde::__private::Err(
754 <__A::Error as _serde::de::Error>::duplicate_field(
755 "describedVersion",
756 ),
757 );
758 }
759 m_describedVersion = _serde::__private::Some(
760 match __A::next_value::<i32>(&mut __map) {
761 _serde::__private::Ok(__val) => __val,
762 _serde::__private::Err(__err) => {
763 return _serde::__private::Err(__err);
764 }
765 },
766 );
767 }
768 _ => __A::skip_value(&mut __map)?,
769 }
770 }
771 let m_name = match m_name {
772 _serde::__private::Some(__field) => __field,
773 _serde::__private::None => {
774 #[cfg(feature = "strict")]
775 return _serde::__private::Err(
776 <__A::Error as _serde::de::Error>::missing_field("name"),
777 );
778 #[cfg(not(feature = "strict"))] Default::default()
779 }
780 };
781 let m_parent = match m_parent {
782 _serde::__private::Some(__field) => __field,
783 _serde::__private::None => {
784 #[cfg(feature = "strict")]
785 return _serde::__private::Err(
786 <__A::Error as _serde::de::Error>::missing_field("parent"),
787 );
788 #[cfg(not(feature = "strict"))] Default::default()
789 }
790 };
791 let m_objectSize = match m_objectSize {
792 _serde::__private::Some(__field) => __field,
793 _serde::__private::None => {
794 #[cfg(feature = "strict")]
795 return _serde::__private::Err(
796 <__A::Error as _serde::de::Error>::missing_field(
797 "objectSize",
798 ),
799 );
800 #[cfg(not(feature = "strict"))] Default::default()
801 }
802 };
803 let m_numImplementedInterfaces = match m_numImplementedInterfaces {
804 _serde::__private::Some(__field) => __field,
805 _serde::__private::None => {
806 #[cfg(feature = "strict")]
807 return _serde::__private::Err(
808 <__A::Error as _serde::de::Error>::missing_field(
809 "numImplementedInterfaces",
810 ),
811 );
812 #[cfg(not(feature = "strict"))] Default::default()
813 }
814 };
815 let m_declaredEnums = match m_declaredEnums {
816 _serde::__private::Some(__field) => __field,
817 _serde::__private::None => {
818 #[cfg(feature = "strict")]
819 return _serde::__private::Err(
820 <__A::Error as _serde::de::Error>::missing_field(
821 "declaredEnums",
822 ),
823 );
824 #[cfg(not(feature = "strict"))] Default::default()
825 }
826 };
827 let m_declaredMembers = match m_declaredMembers {
828 _serde::__private::Some(__field) => __field,
829 _serde::__private::None => {
830 #[cfg(feature = "strict")]
831 return _serde::__private::Err(
832 <__A::Error as _serde::de::Error>::missing_field(
833 "declaredMembers",
834 ),
835 );
836 #[cfg(not(feature = "strict"))] Default::default()
837 }
838 };
839 let m_flags = match m_flags {
840 _serde::__private::Some(__field) => __field,
841 _serde::__private::None => {
842 #[cfg(feature = "strict")]
843 return _serde::__private::Err(
844 <__A::Error as _serde::de::Error>::missing_field("flags"),
845 );
846 #[cfg(not(feature = "strict"))] Default::default()
847 }
848 };
849 let m_describedVersion = match m_describedVersion {
850 _serde::__private::Some(__field) => __field,
851 _serde::__private::None => {
852 #[cfg(feature = "strict")]
853 return _serde::__private::Err(
854 <__A::Error as _serde::de::Error>::missing_field(
855 "describedVersion",
856 ),
857 );
858 #[cfg(not(feature = "strict"))] Default::default()
859 }
860 };
861 let __ptr = __A::class_ptr(&mut __map);
862 _serde::__private::Ok(hkClass {
863 __ptr,
864 m_name,
865 m_parent,
866 m_objectSize,
867 m_numImplementedInterfaces,
868 m_declaredEnums,
869 m_declaredMembers,
870 m_flags,
871 m_describedVersion,
872 ..Default::default()
873 })
874 }
875 }
876 const FIELDS: &[&str] = &[
877 "name",
878 "parent",
879 "objectSize",
880 "numImplementedInterfaces",
881 "declaredEnums",
882 "declaredMembers",
883 "defaults",
884 "attributes",
885 "flags",
886 "describedVersion",
887 ];
888 _serde::Deserializer::deserialize_struct(
889 deserializer,
890 "hkClass",
891 FIELDS,
892 __hkClassVisitor {
893 marker: _serde::__private::PhantomData::<hkClass>,
894 lifetime: _serde::__private::PhantomData,
895 },
896 )
897 }
898 }
899};
900#[havok_types_derive::impl_flags_methods]
901bitflags::bitflags! {
902 #[doc = r" Bit flags"] #[doc = r""] #[doc = r" # C++ Info"] #[doc =
903 " - name: `FlagValues`(ctype: `hkFlags<FlagValues, hkUint32>`)"]
904 #[allow(non_upper_case_globals, non_snake_case)] #[cfg_attr(feature = "serde",
905 derive(serde_with::SerializeDisplay, serde_with::DeserializeFromStr))]
906 #[repr(transparent)] #[derive(Debug, Clone, Copy, PartialEq, Eq, Hash)] pub struct
907 FlagValues : u32 { #[doc = "0"] const FLAGS_NONE = 0u32; #[doc = "1"] const
908 FLAGS_NOT_SERIALIZABLE = 1u32; }
909}
910#[cfg(feature = "json_schema")]
911const _: () = {
912 use schemars::{SchemaGenerator, Schema, JsonSchema, json_schema};
913 use std::borrow::Cow;
914 impl JsonSchema for FlagValues {
915 fn schema_name() -> Cow<'static, str> {
916 "FlagValues".into()
917 }
918 fn schema_id() -> Cow<'static, str> {
919 concat!(module_path!(), "::", "FlagValues").into()
920 }
921 fn json_schema(_generate: &mut SchemaGenerator) -> Schema {
922 json_schema!(
923 { "description" :
924 "Bitflags field. Specific flags: FLAGS_NONE: 0, FLAGS_NOT_SERIALIZABLE: 1. Additional unspecified bits may be set.(e.g.: BIT_FLAG|BIT_FLAG2|4)",
925 "type" : "string", }
926 )
927 }
928 }
929};
930const _: () = {
931 use havok_serde as __serde;
932 impl __serde::Serialize for FlagValues {
933 fn serialize<S>(&self, __serializer: S) -> Result<S::Ok, S::Error>
934 where
935 S: __serde::ser::Serializer,
936 {
937 let mut __serializer = __serializer.serialize_enum_flags()?;
938 if self.is_empty() {
939 __serializer.serialize_bits(&self.bits())?;
940 __serializer.serialize_empty_bit()?;
941 return __serializer.end();
942 }
943 for flag in self.iter() {
944 match flag {
945 Self::FLAGS_NONE => {
946 __serializer.serialize_field("FLAGS_NONE", &Self::FLAGS_NONE)
947 }
948 Self::FLAGS_NOT_SERIALIZABLE => {
949 __serializer
950 .serialize_field(
951 "FLAGS_NOT_SERIALIZABLE",
952 &Self::FLAGS_NOT_SERIALIZABLE,
953 )
954 }
955 remain => {
956 __serializer
957 .serialize_field(&remain.bits().to_string(), &remain.bits())
958 }
959 }?;
960 }
961 __serializer.serialize_bits(&self.bits())?;
962 __serializer.end()
963 }
964 }
965};
966#[doc(hidden)]
967#[allow(non_upper_case_globals, unused_attributes, unused_qualifications)]
968const _: () = {
969 #[allow(unused_extern_crates, clippy::useless_attribute)]
970 extern crate havok_serde as _serde;
971 #[automatically_derived]
972 impl<'de> _serde::Deserialize<'de> for FlagValues {
973 fn deserialize<__D>(
974 __deserializer: __D,
975 ) -> _serde::__private::Result<Self, __D::Error>
976 where
977 __D: _serde::Deserializer<'de>,
978 {
979 #[doc(hidden)]
980 struct __Visitor<'de> {
981 marker: _serde::__private::PhantomData<FlagValues>,
982 lifetime: _serde::__private::PhantomData<&'de ()>,
983 }
984 impl<'de> _serde::de::Visitor<'de> for __Visitor<'de> {
985 type Value = FlagValues;
986 fn expecting(
987 &self,
988 __formatter: &mut _serde::__private::Formatter,
989 ) -> _serde::__private::fmt::Result {
990 _serde::__private::Formatter::write_str(
991 __formatter,
992 "struct FlagValues(flags)",
993 )
994 }
995 #[inline]
996 fn visit_uint32<__E>(
997 self,
998 __value: u32,
999 ) -> _serde::__private::Result<Self::Value, __E>
1000 where
1001 __E: _serde::de::Error,
1002 {
1003 Ok(FlagValues::from_bits_retain(__value as _))
1004 }
1005 fn visit_stringptr<__E>(
1006 self,
1007 __value: StringPtr<'de>,
1008 ) -> _serde::__private::Result<Self::Value, __E>
1009 where
1010 __E: _serde::de::Error,
1011 {
1012 match <FlagValues as core::str::FromStr>::from_str(
1013 __value.into_inner().unwrap().as_ref(),
1014 ) {
1015 Ok(flags) => Ok(flags),
1016 Err(err) => Err(_serde::de::Error::custom(err)),
1017 }
1018 }
1019 }
1020 _serde::Deserializer::deserialize_flags(
1021 __deserializer,
1022 _serde::de::ReadEnumSize::Uint32,
1023 __Visitor {
1024 marker: _serde::__private::PhantomData::<FlagValues>,
1025 lifetime: _serde::__private::PhantomData,
1026 },
1027 )
1028 }
1029 }
1030};