havok_classes/generated/
hkbSetNodePropertyCommand_.rs

1use super::class_requires::*;
2use super::*;
3/// # C++ Info
4/// - name: `hkbSetNodePropertyCommand`
5/// - version: `1`
6/// - signature: `0xc5160b64`
7/// - size: ` 32`(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 hkbSetNodePropertyCommand<'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    pub parent: hkReferencedObject,
30    /// # C++ Info
31    /// - name: `characterId`(ctype: `hkUint64`)
32    /// - offset: `  8`(x86)/` 16`(x86_64)
33    /// - type_size: `  8`(x86)/`  8`(x86_64)
34    #[cfg_attr(feature = "json_schema", schemars(rename = "characterId"))]
35    #[cfg_attr(feature = "serde", serde(rename = "characterId"))]
36    pub m_characterId: u64,
37    /// # C++ Info
38    /// - name: `nodeName`(ctype: `hkStringPtr`)
39    /// - offset: ` 16`(x86)/` 24`(x86_64)
40    /// - type_size: `  4`(x86)/`  8`(x86_64)
41    #[cfg_attr(feature = "serde", serde(borrow))]
42    #[cfg_attr(feature = "json_schema", schemars(rename = "nodeName"))]
43    #[cfg_attr(feature = "serde", serde(rename = "nodeName"))]
44    pub m_nodeName: StringPtr<'a>,
45    /// # C++ Info
46    /// - name: `propertyName`(ctype: `hkStringPtr`)
47    /// - offset: ` 20`(x86)/` 32`(x86_64)
48    /// - type_size: `  4`(x86)/`  8`(x86_64)
49    #[cfg_attr(feature = "serde", serde(borrow))]
50    #[cfg_attr(feature = "json_schema", schemars(rename = "propertyName"))]
51    #[cfg_attr(feature = "serde", serde(rename = "propertyName"))]
52    pub m_propertyName: StringPtr<'a>,
53    /// # C++ Info
54    /// - name: `propertyValue`(ctype: `struct hkbVariableValue`)
55    /// - offset: ` 24`(x86)/` 40`(x86_64)
56    /// - type_size: `  4`(x86)/`  4`(x86_64)
57    #[cfg_attr(feature = "json_schema", schemars(rename = "propertyValue"))]
58    #[cfg_attr(feature = "serde", serde(rename = "propertyValue"))]
59    pub m_propertyValue: hkbVariableValue,
60    /// # C++ Info
61    /// - name: `padding`(ctype: `hkInt32`)
62    /// - offset: ` 28`(x86)/` 44`(x86_64)
63    /// - type_size: `  4`(x86)/`  4`(x86_64)
64    #[cfg_attr(feature = "json_schema", schemars(rename = "padding"))]
65    #[cfg_attr(feature = "serde", serde(rename = "padding"))]
66    pub m_padding: i32,
67}
68const _: () = {
69    use havok_serde as _serde;
70    impl<'a> _serde::HavokClass for hkbSetNodePropertyCommand<'a> {
71        #[inline]
72        fn name(&self) -> &'static str {
73            "hkbSetNodePropertyCommand"
74        }
75        #[inline]
76        fn signature(&self) -> _serde::__private::Signature {
77            _serde::__private::Signature::new(0xc5160b64)
78        }
79        #[allow(clippy::let_and_return, clippy::vec_init_then_push)]
80        fn deps_indexes(&self) -> Vec<usize> {
81            let mut v = Vec::new();
82            v.extend(self.m_propertyValue.deps_indexes());
83            v
84        }
85    }
86    impl<'a> _serde::Serialize for hkbSetNodePropertyCommand<'a> {
87        fn serialize<S>(&self, __serializer: S) -> Result<S::Ok, S::Error>
88        where
89            S: _serde::ser::Serializer,
90        {
91            let class_meta = self
92                .__ptr
93                .map(|name| (name, _serde::__private::Signature::new(0xc5160b64)));
94            let mut serializer = __serializer
95                .serialize_struct(
96                    "hkbSetNodePropertyCommand",
97                    class_meta,
98                    (32u64, 48u64),
99                )?;
100            serializer.pad_field([0u8; 4usize].as_slice(), [0u8; 8usize].as_slice())?;
101            serializer.skip_field("memSizeAndFlags", &self.parent.m_memSizeAndFlags)?;
102            serializer.skip_field("referenceCount", &self.parent.m_referenceCount)?;
103            serializer.pad_field([0u8; 0usize].as_slice(), [0u8; 4usize].as_slice())?;
104            serializer.serialize_field("characterId", &self.m_characterId)?;
105            serializer.serialize_field("nodeName", &self.m_nodeName)?;
106            serializer.serialize_field("propertyName", &self.m_propertyName)?;
107            serializer.serialize_field("propertyValue", &self.m_propertyValue)?;
108            serializer.serialize_field("padding", &self.m_padding)?;
109            serializer.end()
110        }
111    }
112};
113#[doc(hidden)]
114#[allow(non_upper_case_globals, unused_attributes, unused_qualifications)]
115const _: () = {
116    use havok_serde as _serde;
117    #[automatically_derived]
118    impl<'de> _serde::Deserialize<'de> for hkbSetNodePropertyCommand<'de> {
119        fn deserialize<__D>(deserializer: __D) -> core::result::Result<Self, __D::Error>
120        where
121            __D: _serde::Deserializer<'de>,
122        {
123            #[allow(non_camel_case_types)]
124            enum __Field {
125                m_characterId,
126                m_nodeName,
127                m_propertyName,
128                m_propertyValue,
129                m_padding,
130                __ignore,
131            }
132            struct __FieldVisitor;
133            impl<'de> _serde::de::Visitor<'de> for __FieldVisitor {
134                type Value = __Field;
135                fn expecting(
136                    &self,
137                    __formatter: &mut core::fmt::Formatter,
138                ) -> core::fmt::Result {
139                    core::fmt::Formatter::write_str(__formatter, "field identifier")
140                }
141                /// Intended for use in XML.
142                #[allow(clippy::match_single_binding)]
143                #[allow(clippy::reversed_empty_ranges)]
144                #[allow(clippy::single_match)]
145                fn visit_key<__E>(
146                    self,
147                    __value: &str,
148                ) -> core::result::Result<Self::Value, __E>
149                where
150                    __E: _serde::de::Error,
151                {
152                    match __value {
153                        "characterId" => Ok(__Field::m_characterId),
154                        "nodeName" => Ok(__Field::m_nodeName),
155                        "propertyName" => Ok(__Field::m_propertyName),
156                        "propertyValue" => Ok(__Field::m_propertyValue),
157                        "padding" => Ok(__Field::m_padding),
158                        _ => Ok(__Field::__ignore),
159                    }
160                }
161            }
162            impl<'de> _serde::Deserialize<'de> for __Field {
163                #[inline]
164                fn deserialize<__D>(
165                    __deserializer: __D,
166                ) -> core::result::Result<Self, __D::Error>
167                where
168                    __D: _serde::Deserializer<'de>,
169                {
170                    _serde::Deserializer::deserialize_key(__deserializer, __FieldVisitor)
171                }
172            }
173            struct __hkbSetNodePropertyCommandVisitor<'de> {
174                marker: _serde::__private::PhantomData<hkbSetNodePropertyCommand<'de>>,
175                lifetime: _serde::__private::PhantomData<&'de ()>,
176            }
177            #[allow(clippy::match_single_binding)]
178            #[allow(clippy::reversed_empty_ranges)]
179            #[allow(clippy::single_match)]
180            impl<'de> _serde::de::Visitor<'de>
181            for __hkbSetNodePropertyCommandVisitor<'de> {
182                type Value = hkbSetNodePropertyCommand<'de>;
183                fn expecting(
184                    &self,
185                    __formatter: &mut core::fmt::Formatter,
186                ) -> core::fmt::Result {
187                    core::fmt::Formatter::write_str(
188                        __formatter,
189                        "struct hkbSetNodePropertyCommand",
190                    )
191                }
192                fn visit_struct_for_bytes<__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 __ptr = __A::class_ptr(&mut __map);
200                    let parent = __A::parent_value(&mut __map)?;
201                    let mut m_characterId: _serde::__private::Option<u64> = _serde::__private::None;
202                    let mut m_nodeName: _serde::__private::Option<StringPtr<'de>> = _serde::__private::None;
203                    let mut m_propertyName: _serde::__private::Option<StringPtr<'de>> = _serde::__private::None;
204                    let mut m_propertyValue: _serde::__private::Option<
205                        hkbVariableValue,
206                    > = _serde::__private::None;
207                    let mut m_padding: _serde::__private::Option<i32> = _serde::__private::None;
208                    for i in 0..5usize {
209                        match i {
210                            0usize => {
211                                if _serde::__private::Option::is_some(&m_characterId) {
212                                    return _serde::__private::Err(
213                                        <__A::Error as _serde::de::Error>::duplicate_field(
214                                            "characterId",
215                                        ),
216                                    );
217                                }
218                                m_characterId = _serde::__private::Some(
219                                    match __A::next_value::<u64>(&mut __map) {
220                                        _serde::__private::Ok(__val) => __val,
221                                        _serde::__private::Err(__err) => {
222                                            return _serde::__private::Err(__err);
223                                        }
224                                    },
225                                );
226                            }
227                            1usize => {
228                                if _serde::__private::Option::is_some(&m_nodeName) {
229                                    return _serde::__private::Err(
230                                        <__A::Error as _serde::de::Error>::duplicate_field(
231                                            "nodeName",
232                                        ),
233                                    );
234                                }
235                                m_nodeName = _serde::__private::Some(
236                                    match __A::next_value::<StringPtr<'de>>(&mut __map) {
237                                        _serde::__private::Ok(__val) => __val,
238                                        _serde::__private::Err(__err) => {
239                                            return _serde::__private::Err(__err);
240                                        }
241                                    },
242                                );
243                            }
244                            2usize => {
245                                if _serde::__private::Option::is_some(&m_propertyName) {
246                                    return _serde::__private::Err(
247                                        <__A::Error as _serde::de::Error>::duplicate_field(
248                                            "propertyName",
249                                        ),
250                                    );
251                                }
252                                m_propertyName = _serde::__private::Some(
253                                    match __A::next_value::<StringPtr<'de>>(&mut __map) {
254                                        _serde::__private::Ok(__val) => __val,
255                                        _serde::__private::Err(__err) => {
256                                            return _serde::__private::Err(__err);
257                                        }
258                                    },
259                                );
260                            }
261                            3usize => {
262                                if _serde::__private::Option::is_some(&m_propertyValue) {
263                                    return _serde::__private::Err(
264                                        <__A::Error as _serde::de::Error>::duplicate_field(
265                                            "propertyValue",
266                                        ),
267                                    );
268                                }
269                                m_propertyValue = _serde::__private::Some(
270                                    match __A::next_value::<hkbVariableValue>(&mut __map) {
271                                        _serde::__private::Ok(__val) => __val,
272                                        _serde::__private::Err(__err) => {
273                                            return _serde::__private::Err(__err);
274                                        }
275                                    },
276                                );
277                            }
278                            4usize => {
279                                if _serde::__private::Option::is_some(&m_padding) {
280                                    return _serde::__private::Err(
281                                        <__A::Error as _serde::de::Error>::duplicate_field(
282                                            "padding",
283                                        ),
284                                    );
285                                }
286                                m_padding = _serde::__private::Some(
287                                    match __A::next_value::<i32>(&mut __map) {
288                                        _serde::__private::Ok(__val) => __val,
289                                        _serde::__private::Err(__err) => {
290                                            return _serde::__private::Err(__err);
291                                        }
292                                    },
293                                );
294                            }
295                            _ => {}
296                        }
297                    }
298                    let m_characterId = match m_characterId {
299                        _serde::__private::Some(__field) => __field,
300                        _serde::__private::None => {
301                            return _serde::__private::Err(
302                                <__A::Error as _serde::de::Error>::missing_field(
303                                    "characterId",
304                                ),
305                            );
306                        }
307                    };
308                    let m_nodeName = match m_nodeName {
309                        _serde::__private::Some(__field) => __field,
310                        _serde::__private::None => {
311                            return _serde::__private::Err(
312                                <__A::Error as _serde::de::Error>::missing_field("nodeName"),
313                            );
314                        }
315                    };
316                    let m_propertyName = match m_propertyName {
317                        _serde::__private::Some(__field) => __field,
318                        _serde::__private::None => {
319                            return _serde::__private::Err(
320                                <__A::Error as _serde::de::Error>::missing_field(
321                                    "propertyName",
322                                ),
323                            );
324                        }
325                    };
326                    let m_propertyValue = match m_propertyValue {
327                        _serde::__private::Some(__field) => __field,
328                        _serde::__private::None => {
329                            return _serde::__private::Err(
330                                <__A::Error as _serde::de::Error>::missing_field(
331                                    "propertyValue",
332                                ),
333                            );
334                        }
335                    };
336                    let m_padding = match m_padding {
337                        _serde::__private::Some(__field) => __field,
338                        _serde::__private::None => {
339                            return _serde::__private::Err(
340                                <__A::Error as _serde::de::Error>::missing_field("padding"),
341                            );
342                        }
343                    };
344                    _serde::__private::Ok(hkbSetNodePropertyCommand {
345                        __ptr,
346                        parent,
347                        m_characterId,
348                        m_nodeName,
349                        m_propertyName,
350                        m_propertyValue,
351                        m_padding,
352                    })
353                }
354                #[allow(clippy::manual_unwrap_or_default)]
355                fn visit_struct<__A>(
356                    self,
357                    mut __map: __A,
358                ) -> _serde::__private::Result<Self::Value, __A::Error>
359                where
360                    __A: _serde::de::MapAccess<'de>,
361                {
362                    let mut m_characterId: _serde::__private::Option<u64> = _serde::__private::None;
363                    let mut m_nodeName: _serde::__private::Option<StringPtr<'de>> = _serde::__private::None;
364                    let mut m_propertyName: _serde::__private::Option<StringPtr<'de>> = _serde::__private::None;
365                    let mut m_propertyValue: _serde::__private::Option<
366                        hkbVariableValue,
367                    > = _serde::__private::None;
368                    let mut m_padding: _serde::__private::Option<i32> = _serde::__private::None;
369                    while let _serde::__private::Some(__key) = {
370                        __A::next_key::<__Field>(&mut __map)?
371                    } {
372                        match __key {
373                            __Field::m_characterId => {
374                                #[cfg(
375                                    any(feature = "strict", feature = "ignore_duplicates")
376                                )]
377                                if _serde::__private::Option::is_some(&m_characterId) {
378                                    #[cfg(feature = "ignore_duplicates")]
379                                    {
380                                        __A::skip_value(&mut __map)?;
381                                        continue;
382                                    }
383                                    #[cfg(feature = "strict")]
384                                    return _serde::__private::Err(
385                                        <__A::Error as _serde::de::Error>::duplicate_field(
386                                            "characterId",
387                                        ),
388                                    );
389                                }
390                                m_characterId = _serde::__private::Some(
391                                    match __A::next_value::<u64>(&mut __map) {
392                                        _serde::__private::Ok(__val) => __val,
393                                        _serde::__private::Err(__err) => {
394                                            return _serde::__private::Err(__err);
395                                        }
396                                    },
397                                );
398                            }
399                            __Field::m_nodeName => {
400                                #[cfg(
401                                    any(feature = "strict", feature = "ignore_duplicates")
402                                )]
403                                if _serde::__private::Option::is_some(&m_nodeName) {
404                                    #[cfg(feature = "ignore_duplicates")]
405                                    {
406                                        __A::skip_value(&mut __map)?;
407                                        continue;
408                                    }
409                                    #[cfg(feature = "strict")]
410                                    return _serde::__private::Err(
411                                        <__A::Error as _serde::de::Error>::duplicate_field(
412                                            "nodeName",
413                                        ),
414                                    );
415                                }
416                                m_nodeName = _serde::__private::Some(
417                                    match __A::next_value::<StringPtr<'de>>(&mut __map) {
418                                        _serde::__private::Ok(__val) => __val,
419                                        _serde::__private::Err(__err) => {
420                                            return _serde::__private::Err(__err);
421                                        }
422                                    },
423                                );
424                            }
425                            __Field::m_propertyName => {
426                                #[cfg(
427                                    any(feature = "strict", feature = "ignore_duplicates")
428                                )]
429                                if _serde::__private::Option::is_some(&m_propertyName) {
430                                    #[cfg(feature = "ignore_duplicates")]
431                                    {
432                                        __A::skip_value(&mut __map)?;
433                                        continue;
434                                    }
435                                    #[cfg(feature = "strict")]
436                                    return _serde::__private::Err(
437                                        <__A::Error as _serde::de::Error>::duplicate_field(
438                                            "propertyName",
439                                        ),
440                                    );
441                                }
442                                m_propertyName = _serde::__private::Some(
443                                    match __A::next_value::<StringPtr<'de>>(&mut __map) {
444                                        _serde::__private::Ok(__val) => __val,
445                                        _serde::__private::Err(__err) => {
446                                            return _serde::__private::Err(__err);
447                                        }
448                                    },
449                                );
450                            }
451                            __Field::m_propertyValue => {
452                                #[cfg(
453                                    any(feature = "strict", feature = "ignore_duplicates")
454                                )]
455                                if _serde::__private::Option::is_some(&m_propertyValue) {
456                                    #[cfg(feature = "ignore_duplicates")]
457                                    {
458                                        __A::skip_value(&mut __map)?;
459                                        continue;
460                                    }
461                                    #[cfg(feature = "strict")]
462                                    return _serde::__private::Err(
463                                        <__A::Error as _serde::de::Error>::duplicate_field(
464                                            "propertyValue",
465                                        ),
466                                    );
467                                }
468                                m_propertyValue = _serde::__private::Some(
469                                    match __A::next_value::<hkbVariableValue>(&mut __map) {
470                                        _serde::__private::Ok(__val) => __val,
471                                        _serde::__private::Err(__err) => {
472                                            return _serde::__private::Err(__err);
473                                        }
474                                    },
475                                );
476                            }
477                            __Field::m_padding => {
478                                #[cfg(
479                                    any(feature = "strict", feature = "ignore_duplicates")
480                                )]
481                                if _serde::__private::Option::is_some(&m_padding) {
482                                    #[cfg(feature = "ignore_duplicates")]
483                                    {
484                                        __A::skip_value(&mut __map)?;
485                                        continue;
486                                    }
487                                    #[cfg(feature = "strict")]
488                                    return _serde::__private::Err(
489                                        <__A::Error as _serde::de::Error>::duplicate_field(
490                                            "padding",
491                                        ),
492                                    );
493                                }
494                                m_padding = _serde::__private::Some(
495                                    match __A::next_value::<i32>(&mut __map) {
496                                        _serde::__private::Ok(__val) => __val,
497                                        _serde::__private::Err(__err) => {
498                                            return _serde::__private::Err(__err);
499                                        }
500                                    },
501                                );
502                            }
503                            _ => __A::skip_value(&mut __map)?,
504                        }
505                    }
506                    let m_characterId = match m_characterId {
507                        _serde::__private::Some(__field) => __field,
508                        _serde::__private::None => {
509                            #[cfg(feature = "strict")]
510                            return _serde::__private::Err(
511                                <__A::Error as _serde::de::Error>::missing_field(
512                                    "characterId",
513                                ),
514                            );
515                            #[cfg(not(feature = "strict"))] Default::default()
516                        }
517                    };
518                    let m_nodeName = match m_nodeName {
519                        _serde::__private::Some(__field) => __field,
520                        _serde::__private::None => {
521                            #[cfg(feature = "strict")]
522                            return _serde::__private::Err(
523                                <__A::Error as _serde::de::Error>::missing_field("nodeName"),
524                            );
525                            #[cfg(not(feature = "strict"))] Default::default()
526                        }
527                    };
528                    let m_propertyName = match m_propertyName {
529                        _serde::__private::Some(__field) => __field,
530                        _serde::__private::None => {
531                            #[cfg(feature = "strict")]
532                            return _serde::__private::Err(
533                                <__A::Error as _serde::de::Error>::missing_field(
534                                    "propertyName",
535                                ),
536                            );
537                            #[cfg(not(feature = "strict"))] Default::default()
538                        }
539                    };
540                    let m_propertyValue = match m_propertyValue {
541                        _serde::__private::Some(__field) => __field,
542                        _serde::__private::None => {
543                            #[cfg(feature = "strict")]
544                            return _serde::__private::Err(
545                                <__A::Error as _serde::de::Error>::missing_field(
546                                    "propertyValue",
547                                ),
548                            );
549                            #[cfg(not(feature = "strict"))] Default::default()
550                        }
551                    };
552                    let m_padding = match m_padding {
553                        _serde::__private::Some(__field) => __field,
554                        _serde::__private::None => {
555                            #[cfg(feature = "strict")]
556                            return _serde::__private::Err(
557                                <__A::Error as _serde::de::Error>::missing_field("padding"),
558                            );
559                            #[cfg(not(feature = "strict"))] Default::default()
560                        }
561                    };
562                    let __ptr = None;
563                    let parent = hkBaseObject { __ptr };
564                    let parent = hkReferencedObject {
565                        __ptr,
566                        parent,
567                        ..Default::default()
568                    };
569                    let __ptr = __A::class_ptr(&mut __map);
570                    _serde::__private::Ok(hkbSetNodePropertyCommand {
571                        __ptr,
572                        parent,
573                        m_characterId,
574                        m_nodeName,
575                        m_propertyName,
576                        m_propertyValue,
577                        m_padding,
578                    })
579                }
580            }
581            const FIELDS: &[&str] = &[
582                "characterId",
583                "nodeName",
584                "propertyName",
585                "propertyValue",
586                "padding",
587            ];
588            _serde::Deserializer::deserialize_struct(
589                deserializer,
590                "hkbSetNodePropertyCommand",
591                FIELDS,
592                __hkbSetNodePropertyCommandVisitor {
593                    marker: _serde::__private::PhantomData::<hkbSetNodePropertyCommand>,
594                    lifetime: _serde::__private::PhantomData,
595                },
596            )
597        }
598    }
599};
havok_classes/generated/hkbSetNodePropertyCommand_.rs

havok_classes/generated/
hkbSetNodePropertyCommand_.rs
