havok_classes/generated/
hkbBindable_.rs

1use super::class_requires::*;
2use super::*;
3/// # C++ Info
4/// - name: `hkbBindable`
5/// - version: `0`
6/// - signature: `0x2c1432d7`
7/// - size: ` 28`(x86)/` 48`(x86_64)
8/// -  vtable: `true`
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 hkbBindable {
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    /// Alternative to C++ class inheritance.
27    #[cfg_attr(feature = "json_schema", schemars(flatten))]
28    #[cfg_attr(feature = "serde", serde(flatten))]
29    pub parent: hkReferencedObject,
30    /// # C++ Info
31    /// - name: `variableBindingSet`(ctype: `struct hkbVariableBindingSet*`)
32    /// - offset: `  8`(x86)/` 16`(x86_64)
33    /// - type_size: `  4`(x86)/`  8`(x86_64)
34    #[cfg_attr(feature = "json_schema", schemars(rename = "variableBindingSet"))]
35    #[cfg_attr(feature = "serde", serde(rename = "variableBindingSet"))]
36    pub m_variableBindingSet: Pointer,
37    /// # C++ Info
38    /// - name: `cachedBindables`(ctype: `hkArray<void>`)
39    /// - offset: ` 12`(x86)/` 24`(x86_64)
40    /// - type_size: ` 12`(x86)/` 16`(x86_64)
41    /// - flags: `SERIALIZE_IGNORED`
42    #[cfg_attr(feature = "json_schema", schemars(rename = "cachedBindables"))]
43    #[cfg_attr(feature = "serde", serde(rename = "cachedBindables"))]
44    pub m_cachedBindables: Vec<()>,
45    /// # C++ Info
46    /// - name: `areBindablesCached`(ctype: `hkBool`)
47    /// - offset: ` 24`(x86)/` 40`(x86_64)
48    /// - type_size: `  1`(x86)/`  1`(x86_64)
49    /// - flags: `SERIALIZE_IGNORED`
50    #[cfg_attr(feature = "json_schema", schemars(rename = "areBindablesCached"))]
51    #[cfg_attr(feature = "serde", serde(rename = "areBindablesCached"))]
52    pub m_areBindablesCached: bool,
53}
54const _: () = {
55    use havok_serde as _serde;
56    impl _serde::HavokClass for hkbBindable {
57        #[inline]
58        fn name(&self) -> &'static str {
59            "hkbBindable"
60        }
61        #[inline]
62        fn signature(&self) -> _serde::__private::Signature {
63            _serde::__private::Signature::new(0x2c1432d7)
64        }
65        #[allow(clippy::let_and_return, clippy::vec_init_then_push)]
66        fn deps_indexes(&self) -> Vec<usize> {
67            let mut v = Vec::new();
68            v.push(self.m_variableBindingSet.get());
69            v
70        }
71    }
72    impl _serde::Serialize for hkbBindable {
73        fn serialize<S>(&self, __serializer: S) -> Result<S::Ok, S::Error>
74        where
75            S: _serde::ser::Serializer,
76        {
77            let class_meta = self
78                .__ptr
79                .map(|name| (name, _serde::__private::Signature::new(0x2c1432d7)));
80            let mut serializer = __serializer
81                .serialize_struct("hkbBindable", class_meta, (28u64, 48u64))?;
82            serializer.pad_field([0u8; 4usize].as_slice(), [0u8; 8usize].as_slice())?;
83            serializer.skip_field("memSizeAndFlags", &self.parent.m_memSizeAndFlags)?;
84            serializer.skip_field("referenceCount", &self.parent.m_referenceCount)?;
85            serializer.pad_field([0u8; 0usize].as_slice(), [0u8; 4usize].as_slice())?;
86            serializer
87                .serialize_field("variableBindingSet", &self.m_variableBindingSet)?;
88            serializer
89                .skip_array_field(
90                    "cachedBindables",
91                    &self.m_cachedBindables,
92                    TypeSize::NonPtr,
93                )?;
94            serializer.skip_field("areBindablesCached", &self.m_areBindablesCached)?;
95            serializer.pad_field([0u8; 3usize].as_slice(), [0u8; 7usize].as_slice())?;
96            serializer.end()
97        }
98    }
99};
100#[doc(hidden)]
101#[allow(non_upper_case_globals, unused_attributes, unused_qualifications)]
102const _: () = {
103    use havok_serde as _serde;
104    #[automatically_derived]
105    impl<'de> _serde::Deserialize<'de> for hkbBindable {
106        fn deserialize<__D>(deserializer: __D) -> core::result::Result<Self, __D::Error>
107        where
108            __D: _serde::Deserializer<'de>,
109        {
110            #[allow(non_camel_case_types)]
111            enum __Field {
112                m_variableBindingSet,
113                __ignore,
114            }
115            struct __FieldVisitor;
116            impl<'de> _serde::de::Visitor<'de> for __FieldVisitor {
117                type Value = __Field;
118                fn expecting(
119                    &self,
120                    __formatter: &mut core::fmt::Formatter,
121                ) -> core::fmt::Result {
122                    core::fmt::Formatter::write_str(__formatter, "field identifier")
123                }
124                /// Intended for use in XML.
125                #[allow(clippy::match_single_binding)]
126                #[allow(clippy::reversed_empty_ranges)]
127                #[allow(clippy::single_match)]
128                fn visit_key<__E>(
129                    self,
130                    __value: &str,
131                ) -> core::result::Result<Self::Value, __E>
132                where
133                    __E: _serde::de::Error,
134                {
135                    match __value {
136                        "variableBindingSet" => Ok(__Field::m_variableBindingSet),
137                        _ => Ok(__Field::__ignore),
138                    }
139                }
140            }
141            impl<'de> _serde::Deserialize<'de> for __Field {
142                #[inline]
143                fn deserialize<__D>(
144                    __deserializer: __D,
145                ) -> core::result::Result<Self, __D::Error>
146                where
147                    __D: _serde::Deserializer<'de>,
148                {
149                    _serde::Deserializer::deserialize_key(__deserializer, __FieldVisitor)
150                }
151            }
152            struct __hkbBindableVisitor<'de> {
153                marker: _serde::__private::PhantomData<hkbBindable>,
154                lifetime: _serde::__private::PhantomData<&'de ()>,
155            }
156            #[allow(clippy::match_single_binding)]
157            #[allow(clippy::reversed_empty_ranges)]
158            #[allow(clippy::single_match)]
159            impl<'de> _serde::de::Visitor<'de> for __hkbBindableVisitor<'de> {
160                type Value = hkbBindable;
161                fn expecting(
162                    &self,
163                    __formatter: &mut core::fmt::Formatter,
164                ) -> core::fmt::Result {
165                    core::fmt::Formatter::write_str(__formatter, "struct hkbBindable")
166                }
167                fn visit_struct_for_bytes<__A>(
168                    self,
169                    mut __map: __A,
170                ) -> _serde::__private::Result<Self::Value, __A::Error>
171                where
172                    __A: _serde::de::MapAccess<'de>,
173                {
174                    let __ptr = __A::class_ptr(&mut __map);
175                    let parent = __A::parent_value(&mut __map)?;
176                    let mut m_variableBindingSet: _serde::__private::Option<Pointer> = _serde::__private::None;
177                    let mut m_cachedBindables: _serde::__private::Option<Vec<()>> = _serde::__private::None;
178                    let mut m_areBindablesCached: _serde::__private::Option<bool> = _serde::__private::None;
179                    for i in 0..3usize {
180                        match i {
181                            0usize => {
182                                if _serde::__private::Option::is_some(
183                                    &m_variableBindingSet,
184                                ) {
185                                    return _serde::__private::Err(
186                                        <__A::Error as _serde::de::Error>::duplicate_field(
187                                            "variableBindingSet",
188                                        ),
189                                    );
190                                }
191                                m_variableBindingSet = _serde::__private::Some(
192                                    match __A::next_value::<Pointer>(&mut __map) {
193                                        _serde::__private::Ok(__val) => __val,
194                                        _serde::__private::Err(__err) => {
195                                            return _serde::__private::Err(__err);
196                                        }
197                                    },
198                                );
199                            }
200                            1usize => {
201                                if _serde::__private::Option::is_some(&m_cachedBindables) {
202                                    return _serde::__private::Err(
203                                        <__A::Error as _serde::de::Error>::duplicate_field(
204                                            "cachedBindables",
205                                        ),
206                                    );
207                                }
208                                m_cachedBindables = _serde::__private::Some(
209                                    match __A::next_value::<Vec<()>>(&mut __map) {
210                                        _serde::__private::Ok(__val) => __val,
211                                        _serde::__private::Err(__err) => {
212                                            return _serde::__private::Err(__err);
213                                        }
214                                    },
215                                );
216                            }
217                            2usize => {
218                                if _serde::__private::Option::is_some(
219                                    &m_areBindablesCached,
220                                ) {
221                                    return _serde::__private::Err(
222                                        <__A::Error as _serde::de::Error>::duplicate_field(
223                                            "areBindablesCached",
224                                        ),
225                                    );
226                                }
227                                m_areBindablesCached = _serde::__private::Some(
228                                    match __A::next_value::<bool>(&mut __map) {
229                                        _serde::__private::Ok(__val) => __val,
230                                        _serde::__private::Err(__err) => {
231                                            return _serde::__private::Err(__err);
232                                        }
233                                    },
234                                );
235                            }
236                            _ => {}
237                        }
238                    }
239                    __A::pad(&mut __map, 3usize, 7usize)?;
240                    let m_variableBindingSet = match m_variableBindingSet {
241                        _serde::__private::Some(__field) => __field,
242                        _serde::__private::None => {
243                            return _serde::__private::Err(
244                                <__A::Error as _serde::de::Error>::missing_field(
245                                    "variableBindingSet",
246                                ),
247                            );
248                        }
249                    };
250                    let m_cachedBindables = match m_cachedBindables {
251                        _serde::__private::Some(__field) => __field,
252                        _serde::__private::None => {
253                            return _serde::__private::Err(
254                                <__A::Error as _serde::de::Error>::missing_field(
255                                    "cachedBindables",
256                                ),
257                            );
258                        }
259                    };
260                    let m_areBindablesCached = match m_areBindablesCached {
261                        _serde::__private::Some(__field) => __field,
262                        _serde::__private::None => {
263                            return _serde::__private::Err(
264                                <__A::Error as _serde::de::Error>::missing_field(
265                                    "areBindablesCached",
266                                ),
267                            );
268                        }
269                    };
270                    _serde::__private::Ok(hkbBindable {
271                        __ptr,
272                        parent,
273                        m_variableBindingSet,
274                        m_cachedBindables,
275                        m_areBindablesCached,
276                    })
277                }
278                #[allow(clippy::manual_unwrap_or_default)]
279                fn visit_struct<__A>(
280                    self,
281                    mut __map: __A,
282                ) -> _serde::__private::Result<Self::Value, __A::Error>
283                where
284                    __A: _serde::de::MapAccess<'de>,
285                {
286                    let mut m_variableBindingSet: _serde::__private::Option<Pointer> = _serde::__private::None;
287                    while let _serde::__private::Some(__key) = {
288                        __A::next_key::<__Field>(&mut __map)?
289                    } {
290                        match __key {
291                            __Field::m_variableBindingSet => {
292                                #[cfg(
293                                    any(feature = "strict", feature = "ignore_duplicates")
294                                )]
295                                if _serde::__private::Option::is_some(
296                                    &m_variableBindingSet,
297                                ) {
298                                    #[cfg(feature = "ignore_duplicates")]
299                                    {
300                                        __A::skip_value(&mut __map)?;
301                                        continue;
302                                    }
303                                    #[cfg(feature = "strict")]
304                                    return _serde::__private::Err(
305                                        <__A::Error as _serde::de::Error>::duplicate_field(
306                                            "variableBindingSet",
307                                        ),
308                                    );
309                                }
310                                m_variableBindingSet = _serde::__private::Some(
311                                    match __A::next_value::<Pointer>(&mut __map) {
312                                        _serde::__private::Ok(__val) => __val,
313                                        _serde::__private::Err(__err) => {
314                                            return _serde::__private::Err(__err);
315                                        }
316                                    },
317                                );
318                            }
319                            _ => __A::skip_value(&mut __map)?,
320                        }
321                    }
322                    let m_variableBindingSet = match m_variableBindingSet {
323                        _serde::__private::Some(__field) => __field,
324                        _serde::__private::None => {
325                            #[cfg(feature = "strict")]
326                            return _serde::__private::Err(
327                                <__A::Error as _serde::de::Error>::missing_field(
328                                    "variableBindingSet",
329                                ),
330                            );
331                            #[cfg(not(feature = "strict"))] Default::default()
332                        }
333                    };
334                    let __ptr = None;
335                    let parent = hkBaseObject { __ptr };
336                    let parent = hkReferencedObject {
337                        __ptr,
338                        parent,
339                        ..Default::default()
340                    };
341                    let __ptr = __A::class_ptr(&mut __map);
342                    _serde::__private::Ok(hkbBindable {
343                        __ptr,
344                        parent,
345                        m_variableBindingSet,
346                        ..Default::default()
347                    })
348                }
349            }
350            const FIELDS: &[&str] = &[
351                "variableBindingSet",
352                "cachedBindables",
353                "areBindablesCached",
354            ];
355            _serde::Deserializer::deserialize_struct(
356                deserializer,
357                "hkbBindable",
358                FIELDS,
359                __hkbBindableVisitor {
360                    marker: _serde::__private::PhantomData::<hkbBindable>,
361                    lifetime: _serde::__private::PhantomData,
362                },
363            )
364        }
365    }
366};
havok_classes/generated/hkbBindable_.rs

havok_classes/generated/
hkbBindable_.rs
