havok_classes/generated/
hkxMeshUserChannelInfo_.rs

1use super::class_requires::*;
2use super::*;
3/// # C++ Info
4/// - name: `hkxMeshUserChannelInfo`
5/// - version: `0`
6/// - signature: `0x270724a5`
7/// - size: ` 28`(x86)/` 48`(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 hkxMeshUserChannelInfo<'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: hkxAttributeHolder<'a>,
31    /// # C++ Info
32    /// - name: `name`(ctype: `hkStringPtr`)
33    /// - offset: ` 20`(x86)/` 32`(x86_64)
34    /// - type_size: `  4`(x86)/`  8`(x86_64)
35    #[cfg_attr(feature = "serde", serde(borrow))]
36    #[cfg_attr(feature = "json_schema", schemars(rename = "name"))]
37    #[cfg_attr(feature = "serde", serde(rename = "name"))]
38    pub m_name: StringPtr<'a>,
39    /// # C++ Info
40    /// - name: `className`(ctype: `hkStringPtr`)
41    /// - offset: ` 24`(x86)/` 40`(x86_64)
42    /// - type_size: `  4`(x86)/`  8`(x86_64)
43    #[cfg_attr(feature = "serde", serde(borrow))]
44    #[cfg_attr(feature = "json_schema", schemars(rename = "className"))]
45    #[cfg_attr(feature = "serde", serde(rename = "className"))]
46    pub m_className: StringPtr<'a>,
47}
48const _: () = {
49    use havok_serde as _serde;
50    impl<'a> _serde::HavokClass for hkxMeshUserChannelInfo<'a> {
51        #[inline]
52        fn name(&self) -> &'static str {
53            "hkxMeshUserChannelInfo"
54        }
55        #[inline]
56        fn signature(&self) -> _serde::__private::Signature {
57            _serde::__private::Signature::new(0x270724a5)
58        }
59        #[allow(clippy::let_and_return, clippy::vec_init_then_push)]
60        fn deps_indexes(&self) -> Vec<usize> {
61            let mut v = Vec::new();
62            v.extend(
63                self
64                    .parent
65                    .m_attributeGroups
66                    .iter()
67                    .flat_map(|class| class.deps_indexes())
68                    .collect::<Vec<usize>>(),
69            );
70            v
71        }
72    }
73    impl<'a> _serde::Serialize for hkxMeshUserChannelInfo<'a> {
74        fn serialize<S>(&self, __serializer: S) -> Result<S::Ok, S::Error>
75        where
76            S: _serde::ser::Serializer,
77        {
78            let class_meta = self
79                .__ptr
80                .map(|name| (name, _serde::__private::Signature::new(0x270724a5)));
81            let mut serializer = __serializer
82                .serialize_struct("hkxMeshUserChannelInfo", class_meta, (28u64, 48u64))?;
83            serializer.pad_field([0u8; 4usize].as_slice(), [0u8; 8usize].as_slice())?;
84            serializer
85                .skip_field("memSizeAndFlags", &self.parent.parent.m_memSizeAndFlags)?;
86            serializer
87                .skip_field("referenceCount", &self.parent.parent.m_referenceCount)?;
88            serializer.pad_field([0u8; 0usize].as_slice(), [0u8; 4usize].as_slice())?;
89            serializer
90                .serialize_array_field(
91                    "attributeGroups",
92                    &self.parent.m_attributeGroups,
93                    TypeSize::Struct {
94                        size_x86: 16u64,
95                        size_x86_64: 24u64,
96                    },
97                )?;
98            serializer.serialize_field("name", &self.m_name)?;
99            serializer.serialize_field("className", &self.m_className)?;
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 hkxMeshUserChannelInfo<'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_attributeGroups,
117                m_name,
118                m_className,
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                        "attributeGroups" => Ok(__Field::m_attributeGroups),
143                        "name" => Ok(__Field::m_name),
144                        "className" => Ok(__Field::m_className),
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 __hkxMeshUserChannelInfoVisitor<'de> {
161                marker: _serde::__private::PhantomData<hkxMeshUserChannelInfo<'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 __hkxMeshUserChannelInfoVisitor<'de> {
168                type Value = hkxMeshUserChannelInfo<'de>;
169                fn expecting(
170                    &self,
171                    __formatter: &mut core::fmt::Formatter,
172                ) -> core::fmt::Result {
173                    core::fmt::Formatter::write_str(
174                        __formatter,
175                        "struct hkxMeshUserChannelInfo",
176                    )
177                }
178                fn visit_struct_for_bytes<__A>(
179                    self,
180                    mut __map: __A,
181                ) -> _serde::__private::Result<Self::Value, __A::Error>
182                where
183                    __A: _serde::de::MapAccess<'de>,
184                {
185                    let __ptr = __A::class_ptr(&mut __map);
186                    let parent = __A::parent_value(&mut __map)?;
187                    let mut m_name: _serde::__private::Option<StringPtr<'de>> = _serde::__private::None;
188                    let mut m_className: _serde::__private::Option<StringPtr<'de>> = _serde::__private::None;
189                    for i in 0..2usize {
190                        match i {
191                            0usize => {
192                                if _serde::__private::Option::is_some(&m_name) {
193                                    return _serde::__private::Err(
194                                        <__A::Error as _serde::de::Error>::duplicate_field("name"),
195                                    );
196                                }
197                                m_name = _serde::__private::Some(
198                                    match __A::next_value::<StringPtr<'de>>(&mut __map) {
199                                        _serde::__private::Ok(__val) => __val,
200                                        _serde::__private::Err(__err) => {
201                                            return _serde::__private::Err(__err);
202                                        }
203                                    },
204                                );
205                            }
206                            1usize => {
207                                if _serde::__private::Option::is_some(&m_className) {
208                                    return _serde::__private::Err(
209                                        <__A::Error as _serde::de::Error>::duplicate_field(
210                                            "className",
211                                        ),
212                                    );
213                                }
214                                m_className = _serde::__private::Some(
215                                    match __A::next_value::<StringPtr<'de>>(&mut __map) {
216                                        _serde::__private::Ok(__val) => __val,
217                                        _serde::__private::Err(__err) => {
218                                            return _serde::__private::Err(__err);
219                                        }
220                                    },
221                                );
222                            }
223                            _ => {}
224                        }
225                    }
226                    let m_name = match m_name {
227                        _serde::__private::Some(__field) => __field,
228                        _serde::__private::None => {
229                            return _serde::__private::Err(
230                                <__A::Error as _serde::de::Error>::missing_field("name"),
231                            );
232                        }
233                    };
234                    let m_className = match m_className {
235                        _serde::__private::Some(__field) => __field,
236                        _serde::__private::None => {
237                            return _serde::__private::Err(
238                                <__A::Error as _serde::de::Error>::missing_field(
239                                    "className",
240                                ),
241                            );
242                        }
243                    };
244                    _serde::__private::Ok(hkxMeshUserChannelInfo {
245                        __ptr,
246                        parent,
247                        m_name,
248                        m_className,
249                    })
250                }
251                #[allow(clippy::manual_unwrap_or_default)]
252                fn visit_struct<__A>(
253                    self,
254                    mut __map: __A,
255                ) -> _serde::__private::Result<Self::Value, __A::Error>
256                where
257                    __A: _serde::de::MapAccess<'de>,
258                {
259                    let mut m_attributeGroups: _serde::__private::Option<
260                        Vec<hkxAttributeGroup<'de>>,
261                    > = _serde::__private::None;
262                    let mut m_name: _serde::__private::Option<StringPtr<'de>> = _serde::__private::None;
263                    let mut m_className: _serde::__private::Option<StringPtr<'de>> = _serde::__private::None;
264                    while let _serde::__private::Some(__key) = {
265                        __A::next_key::<__Field>(&mut __map)?
266                    } {
267                        match __key {
268                            __Field::m_attributeGroups => {
269                                #[cfg(
270                                    any(feature = "strict", feature = "ignore_duplicates")
271                                )]
272                                if _serde::__private::Option::is_some(&m_attributeGroups) {
273                                    #[cfg(feature = "ignore_duplicates")]
274                                    {
275                                        __A::skip_value(&mut __map)?;
276                                        continue;
277                                    }
278                                    #[cfg(feature = "strict")]
279                                    return _serde::__private::Err(
280                                        <__A::Error as _serde::de::Error>::duplicate_field(
281                                            "attributeGroups",
282                                        ),
283                                    );
284                                }
285                                m_attributeGroups = _serde::__private::Some(
286                                    match __A::next_value::<
287                                        Vec<hkxAttributeGroup<'de>>,
288                                    >(&mut __map) {
289                                        _serde::__private::Ok(__val) => __val,
290                                        _serde::__private::Err(__err) => {
291                                            return _serde::__private::Err(__err);
292                                        }
293                                    },
294                                );
295                            }
296                            __Field::m_name => {
297                                #[cfg(
298                                    any(feature = "strict", feature = "ignore_duplicates")
299                                )]
300                                if _serde::__private::Option::is_some(&m_name) {
301                                    #[cfg(feature = "ignore_duplicates")]
302                                    {
303                                        __A::skip_value(&mut __map)?;
304                                        continue;
305                                    }
306                                    #[cfg(feature = "strict")]
307                                    return _serde::__private::Err(
308                                        <__A::Error as _serde::de::Error>::duplicate_field("name"),
309                                    );
310                                }
311                                m_name = _serde::__private::Some(
312                                    match __A::next_value::<StringPtr<'de>>(&mut __map) {
313                                        _serde::__private::Ok(__val) => __val,
314                                        _serde::__private::Err(__err) => {
315                                            return _serde::__private::Err(__err);
316                                        }
317                                    },
318                                );
319                            }
320                            __Field::m_className => {
321                                #[cfg(
322                                    any(feature = "strict", feature = "ignore_duplicates")
323                                )]
324                                if _serde::__private::Option::is_some(&m_className) {
325                                    #[cfg(feature = "ignore_duplicates")]
326                                    {
327                                        __A::skip_value(&mut __map)?;
328                                        continue;
329                                    }
330                                    #[cfg(feature = "strict")]
331                                    return _serde::__private::Err(
332                                        <__A::Error as _serde::de::Error>::duplicate_field(
333                                            "className",
334                                        ),
335                                    );
336                                }
337                                m_className = _serde::__private::Some(
338                                    match __A::next_value::<StringPtr<'de>>(&mut __map) {
339                                        _serde::__private::Ok(__val) => __val,
340                                        _serde::__private::Err(__err) => {
341                                            return _serde::__private::Err(__err);
342                                        }
343                                    },
344                                );
345                            }
346                            _ => __A::skip_value(&mut __map)?,
347                        }
348                    }
349                    let m_attributeGroups = match m_attributeGroups {
350                        _serde::__private::Some(__field) => __field,
351                        _serde::__private::None => {
352                            #[cfg(feature = "strict")]
353                            return _serde::__private::Err(
354                                <__A::Error as _serde::de::Error>::missing_field(
355                                    "attributeGroups",
356                                ),
357                            );
358                            #[cfg(not(feature = "strict"))] Default::default()
359                        }
360                    };
361                    let m_name = match m_name {
362                        _serde::__private::Some(__field) => __field,
363                        _serde::__private::None => {
364                            #[cfg(feature = "strict")]
365                            return _serde::__private::Err(
366                                <__A::Error as _serde::de::Error>::missing_field("name"),
367                            );
368                            #[cfg(not(feature = "strict"))] Default::default()
369                        }
370                    };
371                    let m_className = match m_className {
372                        _serde::__private::Some(__field) => __field,
373                        _serde::__private::None => {
374                            #[cfg(feature = "strict")]
375                            return _serde::__private::Err(
376                                <__A::Error as _serde::de::Error>::missing_field(
377                                    "className",
378                                ),
379                            );
380                            #[cfg(not(feature = "strict"))] Default::default()
381                        }
382                    };
383                    let __ptr = None;
384                    let parent = hkBaseObject { __ptr };
385                    let parent = hkReferencedObject {
386                        __ptr,
387                        parent,
388                        ..Default::default()
389                    };
390                    let parent = hkxAttributeHolder {
391                        __ptr,
392                        parent,
393                        m_attributeGroups,
394                    };
395                    let __ptr = __A::class_ptr(&mut __map);
396                    _serde::__private::Ok(hkxMeshUserChannelInfo {
397                        __ptr,
398                        parent,
399                        m_name,
400                        m_className,
401                    })
402                }
403            }
404            const FIELDS: &[&str] = &["name", "className"];
405            _serde::Deserializer::deserialize_struct(
406                deserializer,
407                "hkxMeshUserChannelInfo",
408                FIELDS,
409                __hkxMeshUserChannelInfoVisitor {
410                    marker: _serde::__private::PhantomData::<hkxMeshUserChannelInfo>,
411                    lifetime: _serde::__private::PhantomData,
412                },
413            )
414        }
415    }
416};