havok_classes/generated/
hkMultiThreadCheck_.rs

1use super::class_requires::*;
2use super::*;
3/// # C++ Info
4/// - name: `hkMultiThreadCheck`
5/// - version: `0`
6/// - signature: `0x11e4408b`
7/// - size: ` 12`(x86)/` 12`(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 hkMultiThreadCheck {
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: `threadId`(ctype: `hkUint32`)
28    /// - offset: `  0`(x86)/`  0`(x86_64)
29    /// - type_size: `  4`(x86)/`  4`(x86_64)
30    /// - flags: `SERIALIZE_IGNORED`
31    #[cfg_attr(feature = "json_schema", schemars(rename = "threadId"))]
32    #[cfg_attr(feature = "serde", serde(rename = "threadId"))]
33    pub m_threadId: u32,
34    /// # C++ Info
35    /// - name: `stackTraceId`(ctype: `hkInt32`)
36    /// - offset: `  4`(x86)/`  4`(x86_64)
37    /// - type_size: `  4`(x86)/`  4`(x86_64)
38    /// - flags: `SERIALIZE_IGNORED`
39    #[cfg_attr(feature = "json_schema", schemars(rename = "stackTraceId"))]
40    #[cfg_attr(feature = "serde", serde(rename = "stackTraceId"))]
41    pub m_stackTraceId: i32,
42    /// # C++ Info
43    /// - name: `markCount`(ctype: `hkUint16`)
44    /// - offset: `  8`(x86)/`  8`(x86_64)
45    /// - type_size: `  2`(x86)/`  2`(x86_64)
46    /// - flags: `SERIALIZE_IGNORED`
47    #[cfg_attr(feature = "json_schema", schemars(rename = "markCount"))]
48    #[cfg_attr(feature = "serde", serde(rename = "markCount"))]
49    pub m_markCount: u16,
50    /// # C++ Info
51    /// - name: `markBitStack`(ctype: `hkUint16`)
52    /// - offset: ` 10`(x86)/` 10`(x86_64)
53    /// - type_size: `  2`(x86)/`  2`(x86_64)
54    /// - flags: `SERIALIZE_IGNORED`
55    #[cfg_attr(feature = "json_schema", schemars(rename = "markBitStack"))]
56    #[cfg_attr(feature = "serde", serde(rename = "markBitStack"))]
57    pub m_markBitStack: u16,
58}
59const _: () = {
60    use havok_serde as _serde;
61    impl _serde::HavokClass for hkMultiThreadCheck {
62        #[inline]
63        fn name(&self) -> &'static str {
64            "hkMultiThreadCheck"
65        }
66        #[inline]
67        fn signature(&self) -> _serde::__private::Signature {
68            _serde::__private::Signature::new(0x11e4408b)
69        }
70        #[allow(clippy::let_and_return, clippy::vec_init_then_push)]
71        fn deps_indexes(&self) -> Vec<usize> {
72            let mut v = Vec::new();
73            v
74        }
75    }
76    impl _serde::Serialize for hkMultiThreadCheck {
77        fn serialize<S>(&self, __serializer: S) -> Result<S::Ok, S::Error>
78        where
79            S: _serde::ser::Serializer,
80        {
81            let class_meta = self
82                .__ptr
83                .map(|name| (name, _serde::__private::Signature::new(0x11e4408b)));
84            let mut serializer = __serializer
85                .serialize_struct("hkMultiThreadCheck", class_meta, (12u64, 12u64))?;
86            serializer.skip_field("threadId", &self.m_threadId)?;
87            serializer.skip_field("stackTraceId", &self.m_stackTraceId)?;
88            serializer.skip_field("markCount", &self.m_markCount)?;
89            serializer.skip_field("markBitStack", &self.m_markBitStack)?;
90            serializer.end()
91        }
92    }
93};
94#[doc(hidden)]
95#[allow(non_upper_case_globals, unused_attributes, unused_qualifications)]
96const _: () = {
97    use havok_serde as _serde;
98    #[automatically_derived]
99    impl<'de> _serde::Deserialize<'de> for hkMultiThreadCheck {
100        fn deserialize<__D>(deserializer: __D) -> core::result::Result<Self, __D::Error>
101        where
102            __D: _serde::Deserializer<'de>,
103        {
104            #[allow(non_camel_case_types)]
105            enum __Field {
106                __ignore,
107            }
108            struct __FieldVisitor;
109            impl<'de> _serde::de::Visitor<'de> for __FieldVisitor {
110                type Value = __Field;
111                fn expecting(
112                    &self,
113                    __formatter: &mut core::fmt::Formatter,
114                ) -> core::fmt::Result {
115                    core::fmt::Formatter::write_str(__formatter, "field identifier")
116                }
117                /// Intended for use in XML.
118                #[allow(clippy::match_single_binding)]
119                #[allow(clippy::reversed_empty_ranges)]
120                #[allow(clippy::single_match)]
121                fn visit_key<__E>(
122                    self,
123                    __value: &str,
124                ) -> core::result::Result<Self::Value, __E>
125                where
126                    __E: _serde::de::Error,
127                {
128                    match __value {
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 __hkMultiThreadCheckVisitor<'de> {
145                marker: _serde::__private::PhantomData<hkMultiThreadCheck>,
146                lifetime: _serde::__private::PhantomData<&'de ()>,
147            }
148            #[allow(clippy::match_single_binding)]
149            #[allow(clippy::reversed_empty_ranges)]
150            #[allow(clippy::single_match)]
151            impl<'de> _serde::de::Visitor<'de> for __hkMultiThreadCheckVisitor<'de> {
152                type Value = hkMultiThreadCheck;
153                fn expecting(
154                    &self,
155                    __formatter: &mut core::fmt::Formatter,
156                ) -> core::fmt::Result {
157                    core::fmt::Formatter::write_str(
158                        __formatter,
159                        "struct hkMultiThreadCheck",
160                    )
161                }
162                fn visit_struct_for_bytes<__A>(
163                    self,
164                    mut __map: __A,
165                ) -> _serde::__private::Result<Self::Value, __A::Error>
166                where
167                    __A: _serde::de::MapAccess<'de>,
168                {
169                    let __ptr = __A::class_ptr(&mut __map);
170                    let mut m_threadId: _serde::__private::Option<u32> = _serde::__private::None;
171                    let mut m_stackTraceId: _serde::__private::Option<i32> = _serde::__private::None;
172                    let mut m_markCount: _serde::__private::Option<u16> = _serde::__private::None;
173                    let mut m_markBitStack: _serde::__private::Option<u16> = _serde::__private::None;
174                    for i in 0..4usize {
175                        match i {
176                            0usize => {
177                                if _serde::__private::Option::is_some(&m_threadId) {
178                                    return _serde::__private::Err(
179                                        <__A::Error as _serde::de::Error>::duplicate_field(
180                                            "threadId",
181                                        ),
182                                    );
183                                }
184                                m_threadId = _serde::__private::Some(
185                                    match __A::next_value::<u32>(&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_stackTraceId) {
195                                    return _serde::__private::Err(
196                                        <__A::Error as _serde::de::Error>::duplicate_field(
197                                            "stackTraceId",
198                                        ),
199                                    );
200                                }
201                                m_stackTraceId = _serde::__private::Some(
202                                    match __A::next_value::<i32>(&mut __map) {
203                                        _serde::__private::Ok(__val) => __val,
204                                        _serde::__private::Err(__err) => {
205                                            return _serde::__private::Err(__err);
206                                        }
207                                    },
208                                );
209                            }
210                            2usize => {
211                                if _serde::__private::Option::is_some(&m_markCount) {
212                                    return _serde::__private::Err(
213                                        <__A::Error as _serde::de::Error>::duplicate_field(
214                                            "markCount",
215                                        ),
216                                    );
217                                }
218                                m_markCount = _serde::__private::Some(
219                                    match __A::next_value::<u16>(&mut __map) {
220                                        _serde::__private::Ok(__val) => __val,
221                                        _serde::__private::Err(__err) => {
222                                            return _serde::__private::Err(__err);
223                                        }
224                                    },
225                                );
226                            }
227                            3usize => {
228                                if _serde::__private::Option::is_some(&m_markBitStack) {
229                                    return _serde::__private::Err(
230                                        <__A::Error as _serde::de::Error>::duplicate_field(
231                                            "markBitStack",
232                                        ),
233                                    );
234                                }
235                                m_markBitStack = _serde::__private::Some(
236                                    match __A::next_value::<u16>(&mut __map) {
237                                        _serde::__private::Ok(__val) => __val,
238                                        _serde::__private::Err(__err) => {
239                                            return _serde::__private::Err(__err);
240                                        }
241                                    },
242                                );
243                            }
244                            _ => {}
245                        }
246                    }
247                    let m_threadId = match m_threadId {
248                        _serde::__private::Some(__field) => __field,
249                        _serde::__private::None => {
250                            return _serde::__private::Err(
251                                <__A::Error as _serde::de::Error>::missing_field("threadId"),
252                            );
253                        }
254                    };
255                    let m_stackTraceId = match m_stackTraceId {
256                        _serde::__private::Some(__field) => __field,
257                        _serde::__private::None => {
258                            return _serde::__private::Err(
259                                <__A::Error as _serde::de::Error>::missing_field(
260                                    "stackTraceId",
261                                ),
262                            );
263                        }
264                    };
265                    let m_markCount = match m_markCount {
266                        _serde::__private::Some(__field) => __field,
267                        _serde::__private::None => {
268                            return _serde::__private::Err(
269                                <__A::Error as _serde::de::Error>::missing_field(
270                                    "markCount",
271                                ),
272                            );
273                        }
274                    };
275                    let m_markBitStack = match m_markBitStack {
276                        _serde::__private::Some(__field) => __field,
277                        _serde::__private::None => {
278                            return _serde::__private::Err(
279                                <__A::Error as _serde::de::Error>::missing_field(
280                                    "markBitStack",
281                                ),
282                            );
283                        }
284                    };
285                    _serde::__private::Ok(hkMultiThreadCheck {
286                        __ptr,
287                        m_threadId,
288                        m_stackTraceId,
289                        m_markCount,
290                        m_markBitStack,
291                    })
292                }
293                #[allow(clippy::manual_unwrap_or_default)]
294                fn visit_struct<__A>(
295                    self,
296                    mut __map: __A,
297                ) -> _serde::__private::Result<Self::Value, __A::Error>
298                where
299                    __A: _serde::de::MapAccess<'de>,
300                {
301                    while let _serde::__private::Some(__key) = {
302                        __A::next_key::<__Field>(&mut __map)?
303                    } {
304                        match __key {
305                            _ => __A::skip_value(&mut __map)?,
306                        }
307                    }
308                    let __ptr = __A::class_ptr(&mut __map);
309                    _serde::__private::Ok(hkMultiThreadCheck {
310                        __ptr,
311                        ..Default::default()
312                    })
313                }
314            }
315            const FIELDS: &[&str] = &[
316                "threadId",
317                "stackTraceId",
318                "markCount",
319                "markBitStack",
320            ];
321            _serde::Deserializer::deserialize_struct(
322                deserializer,
323                "hkMultiThreadCheck",
324                FIELDS,
325                __hkMultiThreadCheckVisitor {
326                    marker: _serde::__private::PhantomData::<hkMultiThreadCheck>,
327                    lifetime: _serde::__private::PhantomData,
328                },
329            )
330        }
331    }
332};