havok_classes/generated/
hkpBinaryAction_.rs

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

havok_classes/generated/
hkpBinaryAction_.rs
