havok_classes/generated/
hkbEventRaisedInfo_.rs

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

havok_classes/generated/
hkbEventRaisedInfo_.rs
