havok_classes/generated/
hkbGenerator_.rs

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