havok_classes/generated/
hkBitField_.rs

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

havok_classes/generated/
hkBitField_.rs
