havok_classes/generated/
hkpConstraintInstanceSmallArraySerializeOverrideType_.rs

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

havok_classes/generated/
hkpConstraintInstanceSmallArraySerializeOverrideType_.rs
