havok_classes/generated/
hkbVariableBindingSetBinding_.rs

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