havok_classes/generated/
hkClass_.rs

1use super::class_requires::*;
2use super::*;
3/// # C++ Info
4/// - name: `hkClass`
5/// - version: `0`
6/// - signature: `0x75585ef6`
7/// - size: ` 48`(x86)/` 80`(x86_64)
8/// -  vtable: `false`
9#[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    /// # Unique index for this class
16    /// - Represents a pointer on XML (`<hkobject name="#0001"></hkobject>`)
17    /// - [`Option::None`] => This class is `class in field`.(`<hkobject></hkobject>`)
18    ///
19    /// # Note
20    /// Not present in the binary & Not exist actual C++ field.
21    #[cfg_attr(
22        feature = "serde",
23        serde(skip_serializing_if = "Option::is_none", default)
24    )]
25    pub __ptr: Option<Pointer>,
26    /// # C++ Info
27    /// - name: `name`(ctype: `char*`)
28    /// - offset: `  0`(x86)/`  0`(x86_64)
29    /// - type_size: `  4`(x86)/`  8`(x86_64)
30    #[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    /// # C++ Info
35    /// - name: `parent`(ctype: `struct hkClass*`)
36    /// - offset: `  4`(x86)/`  8`(x86_64)
37    /// - type_size: `  4`(x86)/`  8`(x86_64)
38    #[cfg_attr(feature = "json_schema", schemars(rename = "parent"))]
39    #[cfg_attr(feature = "serde", serde(rename = "parent"))]
40    pub m_parent: Pointer,
41    /// # C++ Info
42    /// - name: `objectSize`(ctype: `hkInt32`)
43    /// - offset: `  8`(x86)/` 16`(x86_64)
44    /// - type_size: `  4`(x86)/`  4`(x86_64)
45    #[cfg_attr(feature = "json_schema", schemars(rename = "objectSize"))]
46    #[cfg_attr(feature = "serde", serde(rename = "objectSize"))]
47    pub m_objectSize: i32,
48    /// # C++ Info
49    /// - name: `numImplementedInterfaces`(ctype: `hkInt32`)
50    /// - offset: ` 12`(x86)/` 20`(x86_64)
51    /// - type_size: `  4`(x86)/`  4`(x86_64)
52    #[cfg_attr(feature = "json_schema", schemars(rename = "numImplementedInterfaces"))]
53    #[cfg_attr(feature = "serde", serde(rename = "numImplementedInterfaces"))]
54    pub m_numImplementedInterfaces: i32,
55    /// # C++ Info
56    /// - name: `declaredEnums`(ctype: `hkSimpleArray<struct hkClassEnum>`)
57    /// - offset: ` 16`(x86)/` 24`(x86_64)
58    /// - type_size: `  8`(x86)/` 12`(x86_64)
59    #[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    /// # C++ Info
64    /// - name: `declaredMembers`(ctype: `hkSimpleArray<struct hkClassMember>`)
65    /// - offset: ` 24`(x86)/` 40`(x86_64)
66    /// - type_size: `  8`(x86)/` 12`(x86_64)
67    #[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    /// # C++ Info
72    /// - name: `defaults`(ctype: `void*`)
73    /// - offset: ` 32`(x86)/` 56`(x86_64)
74    /// - type_size: `  4`(x86)/`  8`(x86_64)
75    /// - flags: `SERIALIZE_IGNORED`
76    #[cfg_attr(feature = "json_schema", schemars(rename = "defaults"))]
77    #[cfg_attr(feature = "serde", serde(rename = "defaults"))]
78    pub m_defaults: Pointer,
79    /// # C++ Info
80    /// - name: `attributes`(ctype: `struct hkCustomAttributes*`)
81    /// - offset: ` 36`(x86)/` 64`(x86_64)
82    /// - type_size: `  4`(x86)/`  8`(x86_64)
83    /// - flags: `SERIALIZE_IGNORED`
84    #[cfg_attr(feature = "json_schema", schemars(rename = "attributes"))]
85    #[cfg_attr(feature = "serde", serde(rename = "attributes"))]
86    pub m_attributes: Pointer,
87    /// # C++ Info
88    /// - name: `flags`(ctype: `flags FlagValues`)
89    /// - offset: ` 40`(x86)/` 72`(x86_64)
90    /// - type_size: `  4`(x86)/`  4`(x86_64)
91    #[cfg_attr(feature = "json_schema", schemars(rename = "flags"))]
92    #[cfg_attr(feature = "serde", serde(rename = "flags"))]
93    pub m_flags: FlagValues,
94    /// # C++ Info
95    /// - name: `describedVersion`(ctype: `hkInt32`)
96    /// - offset: ` 44`(x86)/` 76`(x86_64)
97    /// - type_size: `  4`(x86)/`  4`(x86_64)
98    #[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                /// Intended for use in XML.
184                #[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};