havok_classes/generated/
hkMonitorStreamFrameInfo_.rs

1use super::class_requires::*;
2use super::*;
3/// # C++ Info
4/// - name: `hkMonitorStreamFrameInfo`
5/// - version: `0`
6/// - signature: `0x7798b7db`
7/// - size: ` 36`(x86)/` 40`(x86_64)
8/// -  vtable: `false`
9#[allow(non_upper_case_globals, non_snake_case)]
10#[cfg_attr(feature = "json_schema", derive(schemars::JsonSchema))]
11#[cfg_attr(feature = "serde", derive(serde::Serialize, serde::Deserialize))]
12#[derive(educe::Educe)]
13#[educe(Debug, Clone, Default, PartialEq)]
14pub struct hkMonitorStreamFrameInfo<'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    /// # C++ Info
27    /// - name: `heading`(ctype: `hkStringPtr`)
28    /// - offset: `  0`(x86)/`  0`(x86_64)
29    /// - type_size: `  4`(x86)/`  8`(x86_64)
30    #[cfg_attr(feature = "serde", serde(borrow))]
31    #[cfg_attr(feature = "json_schema", schemars(rename = "heading"))]
32    #[cfg_attr(feature = "serde", serde(rename = "heading"))]
33    pub m_heading: StringPtr<'a>,
34    /// # C++ Info
35    /// - name: `indexOfTimer0`(ctype: `hkInt32`)
36    /// - offset: `  4`(x86)/`  8`(x86_64)
37    /// - type_size: `  4`(x86)/`  4`(x86_64)
38    #[cfg_attr(feature = "json_schema", schemars(rename = "indexOfTimer0"))]
39    #[cfg_attr(feature = "serde", serde(rename = "indexOfTimer0"))]
40    pub m_indexOfTimer0: i32,
41    /// # C++ Info
42    /// - name: `indexOfTimer1`(ctype: `hkInt32`)
43    /// - offset: `  8`(x86)/` 12`(x86_64)
44    /// - type_size: `  4`(x86)/`  4`(x86_64)
45    #[cfg_attr(feature = "json_schema", schemars(rename = "indexOfTimer1"))]
46    #[cfg_attr(feature = "serde", serde(rename = "indexOfTimer1"))]
47    pub m_indexOfTimer1: i32,
48    /// # C++ Info
49    /// - name: `absoluteTimeCounter`(ctype: `enum AbsoluteTimeCounter`)
50    /// - offset: ` 12`(x86)/` 16`(x86_64)
51    /// - type_size: `  4`(x86)/`  4`(x86_64)
52    #[cfg_attr(feature = "json_schema", schemars(rename = "absoluteTimeCounter"))]
53    #[cfg_attr(feature = "serde", serde(rename = "absoluteTimeCounter"))]
54    pub m_absoluteTimeCounter: AbsoluteTimeCounter,
55    /// # C++ Info
56    /// - name: `timerFactor0`(ctype: `hkReal`)
57    /// - offset: ` 16`(x86)/` 20`(x86_64)
58    /// - type_size: `  4`(x86)/`  4`(x86_64)
59    #[cfg_attr(feature = "json_schema", schemars(rename = "timerFactor0"))]
60    #[cfg_attr(feature = "serde", serde(rename = "timerFactor0"))]
61    pub m_timerFactor0: f32,
62    /// # C++ Info
63    /// - name: `timerFactor1`(ctype: `hkReal`)
64    /// - offset: ` 20`(x86)/` 24`(x86_64)
65    /// - type_size: `  4`(x86)/`  4`(x86_64)
66    #[cfg_attr(feature = "json_schema", schemars(rename = "timerFactor1"))]
67    #[cfg_attr(feature = "serde", serde(rename = "timerFactor1"))]
68    pub m_timerFactor1: f32,
69    /// # C++ Info
70    /// - name: `threadId`(ctype: `hkInt32`)
71    /// - offset: ` 24`(x86)/` 28`(x86_64)
72    /// - type_size: `  4`(x86)/`  4`(x86_64)
73    #[cfg_attr(feature = "json_schema", schemars(rename = "threadId"))]
74    #[cfg_attr(feature = "serde", serde(rename = "threadId"))]
75    pub m_threadId: i32,
76    /// # C++ Info
77    /// - name: `frameStreamStart`(ctype: `hkInt32`)
78    /// - offset: ` 28`(x86)/` 32`(x86_64)
79    /// - type_size: `  4`(x86)/`  4`(x86_64)
80    #[cfg_attr(feature = "json_schema", schemars(rename = "frameStreamStart"))]
81    #[cfg_attr(feature = "serde", serde(rename = "frameStreamStart"))]
82    pub m_frameStreamStart: i32,
83    /// # C++ Info
84    /// - name: `frameStreamEnd`(ctype: `hkInt32`)
85    /// - offset: ` 32`(x86)/` 36`(x86_64)
86    /// - type_size: `  4`(x86)/`  4`(x86_64)
87    #[cfg_attr(feature = "json_schema", schemars(rename = "frameStreamEnd"))]
88    #[cfg_attr(feature = "serde", serde(rename = "frameStreamEnd"))]
89    pub m_frameStreamEnd: i32,
90}
91const _: () = {
92    use havok_serde as _serde;
93    impl<'a> _serde::HavokClass for hkMonitorStreamFrameInfo<'a> {
94        #[inline]
95        fn name(&self) -> &'static str {
96            "hkMonitorStreamFrameInfo"
97        }
98        #[inline]
99        fn signature(&self) -> _serde::__private::Signature {
100            _serde::__private::Signature::new(0x7798b7db)
101        }
102        #[allow(clippy::let_and_return, clippy::vec_init_then_push)]
103        fn deps_indexes(&self) -> Vec<usize> {
104            let mut v = Vec::new();
105            v
106        }
107    }
108    impl<'a> _serde::Serialize for hkMonitorStreamFrameInfo<'a> {
109        fn serialize<S>(&self, __serializer: S) -> Result<S::Ok, S::Error>
110        where
111            S: _serde::ser::Serializer,
112        {
113            let class_meta = self
114                .__ptr
115                .map(|name| (name, _serde::__private::Signature::new(0x7798b7db)));
116            let mut serializer = __serializer
117                .serialize_struct(
118                    "hkMonitorStreamFrameInfo",
119                    class_meta,
120                    (36u64, 40u64),
121                )?;
122            serializer.serialize_field("heading", &self.m_heading)?;
123            serializer.serialize_field("indexOfTimer0", &self.m_indexOfTimer0)?;
124            serializer.serialize_field("indexOfTimer1", &self.m_indexOfTimer1)?;
125            serializer
126                .serialize_field("absoluteTimeCounter", &self.m_absoluteTimeCounter)?;
127            serializer.serialize_field("timerFactor0", &self.m_timerFactor0)?;
128            serializer.serialize_field("timerFactor1", &self.m_timerFactor1)?;
129            serializer.serialize_field("threadId", &self.m_threadId)?;
130            serializer.serialize_field("frameStreamStart", &self.m_frameStreamStart)?;
131            serializer.serialize_field("frameStreamEnd", &self.m_frameStreamEnd)?;
132            serializer.end()
133        }
134    }
135};
136#[doc(hidden)]
137#[allow(non_upper_case_globals, unused_attributes, unused_qualifications)]
138const _: () = {
139    use havok_serde as _serde;
140    #[automatically_derived]
141    impl<'de> _serde::Deserialize<'de> for hkMonitorStreamFrameInfo<'de> {
142        fn deserialize<__D>(deserializer: __D) -> core::result::Result<Self, __D::Error>
143        where
144            __D: _serde::Deserializer<'de>,
145        {
146            #[allow(non_camel_case_types)]
147            enum __Field {
148                m_heading,
149                m_indexOfTimer0,
150                m_indexOfTimer1,
151                m_absoluteTimeCounter,
152                m_timerFactor0,
153                m_timerFactor1,
154                m_threadId,
155                m_frameStreamStart,
156                m_frameStreamEnd,
157                __ignore,
158            }
159            struct __FieldVisitor;
160            impl<'de> _serde::de::Visitor<'de> for __FieldVisitor {
161                type Value = __Field;
162                fn expecting(
163                    &self,
164                    __formatter: &mut core::fmt::Formatter,
165                ) -> core::fmt::Result {
166                    core::fmt::Formatter::write_str(__formatter, "field identifier")
167                }
168                /// Intended for use in XML.
169                #[allow(clippy::match_single_binding)]
170                #[allow(clippy::reversed_empty_ranges)]
171                #[allow(clippy::single_match)]
172                fn visit_key<__E>(
173                    self,
174                    __value: &str,
175                ) -> core::result::Result<Self::Value, __E>
176                where
177                    __E: _serde::de::Error,
178                {
179                    match __value {
180                        "heading" => Ok(__Field::m_heading),
181                        "indexOfTimer0" => Ok(__Field::m_indexOfTimer0),
182                        "indexOfTimer1" => Ok(__Field::m_indexOfTimer1),
183                        "absoluteTimeCounter" => Ok(__Field::m_absoluteTimeCounter),
184                        "timerFactor0" => Ok(__Field::m_timerFactor0),
185                        "timerFactor1" => Ok(__Field::m_timerFactor1),
186                        "threadId" => Ok(__Field::m_threadId),
187                        "frameStreamStart" => Ok(__Field::m_frameStreamStart),
188                        "frameStreamEnd" => Ok(__Field::m_frameStreamEnd),
189                        _ => Ok(__Field::__ignore),
190                    }
191                }
192            }
193            impl<'de> _serde::Deserialize<'de> for __Field {
194                #[inline]
195                fn deserialize<__D>(
196                    __deserializer: __D,
197                ) -> core::result::Result<Self, __D::Error>
198                where
199                    __D: _serde::Deserializer<'de>,
200                {
201                    _serde::Deserializer::deserialize_key(__deserializer, __FieldVisitor)
202                }
203            }
204            struct __hkMonitorStreamFrameInfoVisitor<'de> {
205                marker: _serde::__private::PhantomData<hkMonitorStreamFrameInfo<'de>>,
206                lifetime: _serde::__private::PhantomData<&'de ()>,
207            }
208            #[allow(clippy::match_single_binding)]
209            #[allow(clippy::reversed_empty_ranges)]
210            #[allow(clippy::single_match)]
211            impl<'de> _serde::de::Visitor<'de>
212            for __hkMonitorStreamFrameInfoVisitor<'de> {
213                type Value = hkMonitorStreamFrameInfo<'de>;
214                fn expecting(
215                    &self,
216                    __formatter: &mut core::fmt::Formatter,
217                ) -> core::fmt::Result {
218                    core::fmt::Formatter::write_str(
219                        __formatter,
220                        "struct hkMonitorStreamFrameInfo",
221                    )
222                }
223                fn visit_struct_for_bytes<__A>(
224                    self,
225                    mut __map: __A,
226                ) -> _serde::__private::Result<Self::Value, __A::Error>
227                where
228                    __A: _serde::de::MapAccess<'de>,
229                {
230                    let __ptr = __A::class_ptr(&mut __map);
231                    let mut m_heading: _serde::__private::Option<StringPtr<'de>> = _serde::__private::None;
232                    let mut m_indexOfTimer0: _serde::__private::Option<i32> = _serde::__private::None;
233                    let mut m_indexOfTimer1: _serde::__private::Option<i32> = _serde::__private::None;
234                    let mut m_absoluteTimeCounter: _serde::__private::Option<
235                        AbsoluteTimeCounter,
236                    > = _serde::__private::None;
237                    let mut m_timerFactor0: _serde::__private::Option<f32> = _serde::__private::None;
238                    let mut m_timerFactor1: _serde::__private::Option<f32> = _serde::__private::None;
239                    let mut m_threadId: _serde::__private::Option<i32> = _serde::__private::None;
240                    let mut m_frameStreamStart: _serde::__private::Option<i32> = _serde::__private::None;
241                    let mut m_frameStreamEnd: _serde::__private::Option<i32> = _serde::__private::None;
242                    for i in 0..9usize {
243                        match i {
244                            0usize => {
245                                if _serde::__private::Option::is_some(&m_heading) {
246                                    return _serde::__private::Err(
247                                        <__A::Error as _serde::de::Error>::duplicate_field(
248                                            "heading",
249                                        ),
250                                    );
251                                }
252                                m_heading = _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                            1usize => {
262                                if _serde::__private::Option::is_some(&m_indexOfTimer0) {
263                                    return _serde::__private::Err(
264                                        <__A::Error as _serde::de::Error>::duplicate_field(
265                                            "indexOfTimer0",
266                                        ),
267                                    );
268                                }
269                                m_indexOfTimer0 = _serde::__private::Some(
270                                    match __A::next_value::<i32>(&mut __map) {
271                                        _serde::__private::Ok(__val) => __val,
272                                        _serde::__private::Err(__err) => {
273                                            return _serde::__private::Err(__err);
274                                        }
275                                    },
276                                );
277                            }
278                            2usize => {
279                                if _serde::__private::Option::is_some(&m_indexOfTimer1) {
280                                    return _serde::__private::Err(
281                                        <__A::Error as _serde::de::Error>::duplicate_field(
282                                            "indexOfTimer1",
283                                        ),
284                                    );
285                                }
286                                m_indexOfTimer1 = _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                            3usize => {
296                                if _serde::__private::Option::is_some(
297                                    &m_absoluteTimeCounter,
298                                ) {
299                                    return _serde::__private::Err(
300                                        <__A::Error as _serde::de::Error>::duplicate_field(
301                                            "absoluteTimeCounter",
302                                        ),
303                                    );
304                                }
305                                m_absoluteTimeCounter = _serde::__private::Some(
306                                    match __A::next_value::<AbsoluteTimeCounter>(&mut __map) {
307                                        _serde::__private::Ok(__val) => __val,
308                                        _serde::__private::Err(__err) => {
309                                            return _serde::__private::Err(__err);
310                                        }
311                                    },
312                                );
313                            }
314                            4usize => {
315                                if _serde::__private::Option::is_some(&m_timerFactor0) {
316                                    return _serde::__private::Err(
317                                        <__A::Error as _serde::de::Error>::duplicate_field(
318                                            "timerFactor0",
319                                        ),
320                                    );
321                                }
322                                m_timerFactor0 = _serde::__private::Some(
323                                    match __A::next_value::<f32>(&mut __map) {
324                                        _serde::__private::Ok(__val) => __val,
325                                        _serde::__private::Err(__err) => {
326                                            return _serde::__private::Err(__err);
327                                        }
328                                    },
329                                );
330                            }
331                            5usize => {
332                                if _serde::__private::Option::is_some(&m_timerFactor1) {
333                                    return _serde::__private::Err(
334                                        <__A::Error as _serde::de::Error>::duplicate_field(
335                                            "timerFactor1",
336                                        ),
337                                    );
338                                }
339                                m_timerFactor1 = _serde::__private::Some(
340                                    match __A::next_value::<f32>(&mut __map) {
341                                        _serde::__private::Ok(__val) => __val,
342                                        _serde::__private::Err(__err) => {
343                                            return _serde::__private::Err(__err);
344                                        }
345                                    },
346                                );
347                            }
348                            6usize => {
349                                if _serde::__private::Option::is_some(&m_threadId) {
350                                    return _serde::__private::Err(
351                                        <__A::Error as _serde::de::Error>::duplicate_field(
352                                            "threadId",
353                                        ),
354                                    );
355                                }
356                                m_threadId = _serde::__private::Some(
357                                    match __A::next_value::<i32>(&mut __map) {
358                                        _serde::__private::Ok(__val) => __val,
359                                        _serde::__private::Err(__err) => {
360                                            return _serde::__private::Err(__err);
361                                        }
362                                    },
363                                );
364                            }
365                            7usize => {
366                                if _serde::__private::Option::is_some(&m_frameStreamStart) {
367                                    return _serde::__private::Err(
368                                        <__A::Error as _serde::de::Error>::duplicate_field(
369                                            "frameStreamStart",
370                                        ),
371                                    );
372                                }
373                                m_frameStreamStart = _serde::__private::Some(
374                                    match __A::next_value::<i32>(&mut __map) {
375                                        _serde::__private::Ok(__val) => __val,
376                                        _serde::__private::Err(__err) => {
377                                            return _serde::__private::Err(__err);
378                                        }
379                                    },
380                                );
381                            }
382                            8usize => {
383                                if _serde::__private::Option::is_some(&m_frameStreamEnd) {
384                                    return _serde::__private::Err(
385                                        <__A::Error as _serde::de::Error>::duplicate_field(
386                                            "frameStreamEnd",
387                                        ),
388                                    );
389                                }
390                                m_frameStreamEnd = _serde::__private::Some(
391                                    match __A::next_value::<i32>(&mut __map) {
392                                        _serde::__private::Ok(__val) => __val,
393                                        _serde::__private::Err(__err) => {
394                                            return _serde::__private::Err(__err);
395                                        }
396                                    },
397                                );
398                            }
399                            _ => {}
400                        }
401                    }
402                    let m_heading = match m_heading {
403                        _serde::__private::Some(__field) => __field,
404                        _serde::__private::None => {
405                            return _serde::__private::Err(
406                                <__A::Error as _serde::de::Error>::missing_field("heading"),
407                            );
408                        }
409                    };
410                    let m_indexOfTimer0 = match m_indexOfTimer0 {
411                        _serde::__private::Some(__field) => __field,
412                        _serde::__private::None => {
413                            return _serde::__private::Err(
414                                <__A::Error as _serde::de::Error>::missing_field(
415                                    "indexOfTimer0",
416                                ),
417                            );
418                        }
419                    };
420                    let m_indexOfTimer1 = match m_indexOfTimer1 {
421                        _serde::__private::Some(__field) => __field,
422                        _serde::__private::None => {
423                            return _serde::__private::Err(
424                                <__A::Error as _serde::de::Error>::missing_field(
425                                    "indexOfTimer1",
426                                ),
427                            );
428                        }
429                    };
430                    let m_absoluteTimeCounter = match m_absoluteTimeCounter {
431                        _serde::__private::Some(__field) => __field,
432                        _serde::__private::None => {
433                            return _serde::__private::Err(
434                                <__A::Error as _serde::de::Error>::missing_field(
435                                    "absoluteTimeCounter",
436                                ),
437                            );
438                        }
439                    };
440                    let m_timerFactor0 = match m_timerFactor0 {
441                        _serde::__private::Some(__field) => __field,
442                        _serde::__private::None => {
443                            return _serde::__private::Err(
444                                <__A::Error as _serde::de::Error>::missing_field(
445                                    "timerFactor0",
446                                ),
447                            );
448                        }
449                    };
450                    let m_timerFactor1 = match m_timerFactor1 {
451                        _serde::__private::Some(__field) => __field,
452                        _serde::__private::None => {
453                            return _serde::__private::Err(
454                                <__A::Error as _serde::de::Error>::missing_field(
455                                    "timerFactor1",
456                                ),
457                            );
458                        }
459                    };
460                    let m_threadId = match m_threadId {
461                        _serde::__private::Some(__field) => __field,
462                        _serde::__private::None => {
463                            return _serde::__private::Err(
464                                <__A::Error as _serde::de::Error>::missing_field("threadId"),
465                            );
466                        }
467                    };
468                    let m_frameStreamStart = match m_frameStreamStart {
469                        _serde::__private::Some(__field) => __field,
470                        _serde::__private::None => {
471                            return _serde::__private::Err(
472                                <__A::Error as _serde::de::Error>::missing_field(
473                                    "frameStreamStart",
474                                ),
475                            );
476                        }
477                    };
478                    let m_frameStreamEnd = match m_frameStreamEnd {
479                        _serde::__private::Some(__field) => __field,
480                        _serde::__private::None => {
481                            return _serde::__private::Err(
482                                <__A::Error as _serde::de::Error>::missing_field(
483                                    "frameStreamEnd",
484                                ),
485                            );
486                        }
487                    };
488                    _serde::__private::Ok(hkMonitorStreamFrameInfo {
489                        __ptr,
490                        m_heading,
491                        m_indexOfTimer0,
492                        m_indexOfTimer1,
493                        m_absoluteTimeCounter,
494                        m_timerFactor0,
495                        m_timerFactor1,
496                        m_threadId,
497                        m_frameStreamStart,
498                        m_frameStreamEnd,
499                    })
500                }
501                #[allow(clippy::manual_unwrap_or_default)]
502                fn visit_struct<__A>(
503                    self,
504                    mut __map: __A,
505                ) -> _serde::__private::Result<Self::Value, __A::Error>
506                where
507                    __A: _serde::de::MapAccess<'de>,
508                {
509                    let mut m_heading: _serde::__private::Option<StringPtr<'de>> = _serde::__private::None;
510                    let mut m_indexOfTimer0: _serde::__private::Option<i32> = _serde::__private::None;
511                    let mut m_indexOfTimer1: _serde::__private::Option<i32> = _serde::__private::None;
512                    let mut m_absoluteTimeCounter: _serde::__private::Option<
513                        AbsoluteTimeCounter,
514                    > = _serde::__private::None;
515                    let mut m_timerFactor0: _serde::__private::Option<f32> = _serde::__private::None;
516                    let mut m_timerFactor1: _serde::__private::Option<f32> = _serde::__private::None;
517                    let mut m_threadId: _serde::__private::Option<i32> = _serde::__private::None;
518                    let mut m_frameStreamStart: _serde::__private::Option<i32> = _serde::__private::None;
519                    let mut m_frameStreamEnd: _serde::__private::Option<i32> = _serde::__private::None;
520                    while let _serde::__private::Some(__key) = {
521                        __A::next_key::<__Field>(&mut __map)?
522                    } {
523                        match __key {
524                            __Field::m_heading => {
525                                #[cfg(
526                                    any(feature = "strict", feature = "ignore_duplicates")
527                                )]
528                                if _serde::__private::Option::is_some(&m_heading) {
529                                    #[cfg(feature = "ignore_duplicates")]
530                                    {
531                                        __A::skip_value(&mut __map)?;
532                                        continue;
533                                    }
534                                    #[cfg(feature = "strict")]
535                                    return _serde::__private::Err(
536                                        <__A::Error as _serde::de::Error>::duplicate_field(
537                                            "heading",
538                                        ),
539                                    );
540                                }
541                                m_heading = _serde::__private::Some(
542                                    match __A::next_value::<StringPtr<'de>>(&mut __map) {
543                                        _serde::__private::Ok(__val) => __val,
544                                        _serde::__private::Err(__err) => {
545                                            return _serde::__private::Err(__err);
546                                        }
547                                    },
548                                );
549                            }
550                            __Field::m_indexOfTimer0 => {
551                                #[cfg(
552                                    any(feature = "strict", feature = "ignore_duplicates")
553                                )]
554                                if _serde::__private::Option::is_some(&m_indexOfTimer0) {
555                                    #[cfg(feature = "ignore_duplicates")]
556                                    {
557                                        __A::skip_value(&mut __map)?;
558                                        continue;
559                                    }
560                                    #[cfg(feature = "strict")]
561                                    return _serde::__private::Err(
562                                        <__A::Error as _serde::de::Error>::duplicate_field(
563                                            "indexOfTimer0",
564                                        ),
565                                    );
566                                }
567                                m_indexOfTimer0 = _serde::__private::Some(
568                                    match __A::next_value::<i32>(&mut __map) {
569                                        _serde::__private::Ok(__val) => __val,
570                                        _serde::__private::Err(__err) => {
571                                            return _serde::__private::Err(__err);
572                                        }
573                                    },
574                                );
575                            }
576                            __Field::m_indexOfTimer1 => {
577                                #[cfg(
578                                    any(feature = "strict", feature = "ignore_duplicates")
579                                )]
580                                if _serde::__private::Option::is_some(&m_indexOfTimer1) {
581                                    #[cfg(feature = "ignore_duplicates")]
582                                    {
583                                        __A::skip_value(&mut __map)?;
584                                        continue;
585                                    }
586                                    #[cfg(feature = "strict")]
587                                    return _serde::__private::Err(
588                                        <__A::Error as _serde::de::Error>::duplicate_field(
589                                            "indexOfTimer1",
590                                        ),
591                                    );
592                                }
593                                m_indexOfTimer1 = _serde::__private::Some(
594                                    match __A::next_value::<i32>(&mut __map) {
595                                        _serde::__private::Ok(__val) => __val,
596                                        _serde::__private::Err(__err) => {
597                                            return _serde::__private::Err(__err);
598                                        }
599                                    },
600                                );
601                            }
602                            __Field::m_absoluteTimeCounter => {
603                                #[cfg(
604                                    any(feature = "strict", feature = "ignore_duplicates")
605                                )]
606                                if _serde::__private::Option::is_some(
607                                    &m_absoluteTimeCounter,
608                                ) {
609                                    #[cfg(feature = "ignore_duplicates")]
610                                    {
611                                        __A::skip_value(&mut __map)?;
612                                        continue;
613                                    }
614                                    #[cfg(feature = "strict")]
615                                    return _serde::__private::Err(
616                                        <__A::Error as _serde::de::Error>::duplicate_field(
617                                            "absoluteTimeCounter",
618                                        ),
619                                    );
620                                }
621                                m_absoluteTimeCounter = _serde::__private::Some(
622                                    match __A::next_value::<AbsoluteTimeCounter>(&mut __map) {
623                                        _serde::__private::Ok(__val) => __val,
624                                        _serde::__private::Err(__err) => {
625                                            return _serde::__private::Err(__err);
626                                        }
627                                    },
628                                );
629                            }
630                            __Field::m_timerFactor0 => {
631                                #[cfg(
632                                    any(feature = "strict", feature = "ignore_duplicates")
633                                )]
634                                if _serde::__private::Option::is_some(&m_timerFactor0) {
635                                    #[cfg(feature = "ignore_duplicates")]
636                                    {
637                                        __A::skip_value(&mut __map)?;
638                                        continue;
639                                    }
640                                    #[cfg(feature = "strict")]
641                                    return _serde::__private::Err(
642                                        <__A::Error as _serde::de::Error>::duplicate_field(
643                                            "timerFactor0",
644                                        ),
645                                    );
646                                }
647                                m_timerFactor0 = _serde::__private::Some(
648                                    match __A::next_value::<f32>(&mut __map) {
649                                        _serde::__private::Ok(__val) => __val,
650                                        _serde::__private::Err(__err) => {
651                                            return _serde::__private::Err(__err);
652                                        }
653                                    },
654                                );
655                            }
656                            __Field::m_timerFactor1 => {
657                                #[cfg(
658                                    any(feature = "strict", feature = "ignore_duplicates")
659                                )]
660                                if _serde::__private::Option::is_some(&m_timerFactor1) {
661                                    #[cfg(feature = "ignore_duplicates")]
662                                    {
663                                        __A::skip_value(&mut __map)?;
664                                        continue;
665                                    }
666                                    #[cfg(feature = "strict")]
667                                    return _serde::__private::Err(
668                                        <__A::Error as _serde::de::Error>::duplicate_field(
669                                            "timerFactor1",
670                                        ),
671                                    );
672                                }
673                                m_timerFactor1 = _serde::__private::Some(
674                                    match __A::next_value::<f32>(&mut __map) {
675                                        _serde::__private::Ok(__val) => __val,
676                                        _serde::__private::Err(__err) => {
677                                            return _serde::__private::Err(__err);
678                                        }
679                                    },
680                                );
681                            }
682                            __Field::m_threadId => {
683                                #[cfg(
684                                    any(feature = "strict", feature = "ignore_duplicates")
685                                )]
686                                if _serde::__private::Option::is_some(&m_threadId) {
687                                    #[cfg(feature = "ignore_duplicates")]
688                                    {
689                                        __A::skip_value(&mut __map)?;
690                                        continue;
691                                    }
692                                    #[cfg(feature = "strict")]
693                                    return _serde::__private::Err(
694                                        <__A::Error as _serde::de::Error>::duplicate_field(
695                                            "threadId",
696                                        ),
697                                    );
698                                }
699                                m_threadId = _serde::__private::Some(
700                                    match __A::next_value::<i32>(&mut __map) {
701                                        _serde::__private::Ok(__val) => __val,
702                                        _serde::__private::Err(__err) => {
703                                            return _serde::__private::Err(__err);
704                                        }
705                                    },
706                                );
707                            }
708                            __Field::m_frameStreamStart => {
709                                #[cfg(
710                                    any(feature = "strict", feature = "ignore_duplicates")
711                                )]
712                                if _serde::__private::Option::is_some(&m_frameStreamStart) {
713                                    #[cfg(feature = "ignore_duplicates")]
714                                    {
715                                        __A::skip_value(&mut __map)?;
716                                        continue;
717                                    }
718                                    #[cfg(feature = "strict")]
719                                    return _serde::__private::Err(
720                                        <__A::Error as _serde::de::Error>::duplicate_field(
721                                            "frameStreamStart",
722                                        ),
723                                    );
724                                }
725                                m_frameStreamStart = _serde::__private::Some(
726                                    match __A::next_value::<i32>(&mut __map) {
727                                        _serde::__private::Ok(__val) => __val,
728                                        _serde::__private::Err(__err) => {
729                                            return _serde::__private::Err(__err);
730                                        }
731                                    },
732                                );
733                            }
734                            __Field::m_frameStreamEnd => {
735                                #[cfg(
736                                    any(feature = "strict", feature = "ignore_duplicates")
737                                )]
738                                if _serde::__private::Option::is_some(&m_frameStreamEnd) {
739                                    #[cfg(feature = "ignore_duplicates")]
740                                    {
741                                        __A::skip_value(&mut __map)?;
742                                        continue;
743                                    }
744                                    #[cfg(feature = "strict")]
745                                    return _serde::__private::Err(
746                                        <__A::Error as _serde::de::Error>::duplicate_field(
747                                            "frameStreamEnd",
748                                        ),
749                                    );
750                                }
751                                m_frameStreamEnd = _serde::__private::Some(
752                                    match __A::next_value::<i32>(&mut __map) {
753                                        _serde::__private::Ok(__val) => __val,
754                                        _serde::__private::Err(__err) => {
755                                            return _serde::__private::Err(__err);
756                                        }
757                                    },
758                                );
759                            }
760                            _ => __A::skip_value(&mut __map)?,
761                        }
762                    }
763                    let m_heading = match m_heading {
764                        _serde::__private::Some(__field) => __field,
765                        _serde::__private::None => {
766                            #[cfg(feature = "strict")]
767                            return _serde::__private::Err(
768                                <__A::Error as _serde::de::Error>::missing_field("heading"),
769                            );
770                            #[cfg(not(feature = "strict"))] Default::default()
771                        }
772                    };
773                    let m_indexOfTimer0 = match m_indexOfTimer0 {
774                        _serde::__private::Some(__field) => __field,
775                        _serde::__private::None => {
776                            #[cfg(feature = "strict")]
777                            return _serde::__private::Err(
778                                <__A::Error as _serde::de::Error>::missing_field(
779                                    "indexOfTimer0",
780                                ),
781                            );
782                            #[cfg(not(feature = "strict"))] Default::default()
783                        }
784                    };
785                    let m_indexOfTimer1 = match m_indexOfTimer1 {
786                        _serde::__private::Some(__field) => __field,
787                        _serde::__private::None => {
788                            #[cfg(feature = "strict")]
789                            return _serde::__private::Err(
790                                <__A::Error as _serde::de::Error>::missing_field(
791                                    "indexOfTimer1",
792                                ),
793                            );
794                            #[cfg(not(feature = "strict"))] Default::default()
795                        }
796                    };
797                    let m_absoluteTimeCounter = match m_absoluteTimeCounter {
798                        _serde::__private::Some(__field) => __field,
799                        _serde::__private::None => {
800                            #[cfg(feature = "strict")]
801                            return _serde::__private::Err(
802                                <__A::Error as _serde::de::Error>::missing_field(
803                                    "absoluteTimeCounter",
804                                ),
805                            );
806                            #[cfg(not(feature = "strict"))] Default::default()
807                        }
808                    };
809                    let m_timerFactor0 = match m_timerFactor0 {
810                        _serde::__private::Some(__field) => __field,
811                        _serde::__private::None => {
812                            #[cfg(feature = "strict")]
813                            return _serde::__private::Err(
814                                <__A::Error as _serde::de::Error>::missing_field(
815                                    "timerFactor0",
816                                ),
817                            );
818                            #[cfg(not(feature = "strict"))] Default::default()
819                        }
820                    };
821                    let m_timerFactor1 = match m_timerFactor1 {
822                        _serde::__private::Some(__field) => __field,
823                        _serde::__private::None => {
824                            #[cfg(feature = "strict")]
825                            return _serde::__private::Err(
826                                <__A::Error as _serde::de::Error>::missing_field(
827                                    "timerFactor1",
828                                ),
829                            );
830                            #[cfg(not(feature = "strict"))] Default::default()
831                        }
832                    };
833                    let m_threadId = match m_threadId {
834                        _serde::__private::Some(__field) => __field,
835                        _serde::__private::None => {
836                            #[cfg(feature = "strict")]
837                            return _serde::__private::Err(
838                                <__A::Error as _serde::de::Error>::missing_field("threadId"),
839                            );
840                            #[cfg(not(feature = "strict"))] Default::default()
841                        }
842                    };
843                    let m_frameStreamStart = match m_frameStreamStart {
844                        _serde::__private::Some(__field) => __field,
845                        _serde::__private::None => {
846                            #[cfg(feature = "strict")]
847                            return _serde::__private::Err(
848                                <__A::Error as _serde::de::Error>::missing_field(
849                                    "frameStreamStart",
850                                ),
851                            );
852                            #[cfg(not(feature = "strict"))] Default::default()
853                        }
854                    };
855                    let m_frameStreamEnd = match m_frameStreamEnd {
856                        _serde::__private::Some(__field) => __field,
857                        _serde::__private::None => {
858                            #[cfg(feature = "strict")]
859                            return _serde::__private::Err(
860                                <__A::Error as _serde::de::Error>::missing_field(
861                                    "frameStreamEnd",
862                                ),
863                            );
864                            #[cfg(not(feature = "strict"))] Default::default()
865                        }
866                    };
867                    let __ptr = __A::class_ptr(&mut __map);
868                    _serde::__private::Ok(hkMonitorStreamFrameInfo {
869                        __ptr,
870                        m_heading,
871                        m_indexOfTimer0,
872                        m_indexOfTimer1,
873                        m_absoluteTimeCounter,
874                        m_timerFactor0,
875                        m_timerFactor1,
876                        m_threadId,
877                        m_frameStreamStart,
878                        m_frameStreamEnd,
879                    })
880                }
881            }
882            const FIELDS: &[&str] = &[
883                "heading",
884                "indexOfTimer0",
885                "indexOfTimer1",
886                "absoluteTimeCounter",
887                "timerFactor0",
888                "timerFactor1",
889                "threadId",
890                "frameStreamStart",
891                "frameStreamEnd",
892            ];
893            _serde::Deserializer::deserialize_struct(
894                deserializer,
895                "hkMonitorStreamFrameInfo",
896                FIELDS,
897                __hkMonitorStreamFrameInfoVisitor {
898                    marker: _serde::__private::PhantomData::<hkMonitorStreamFrameInfo>,
899                    lifetime: _serde::__private::PhantomData,
900                },
901            )
902        }
903    }
904};
905/// # C++ Info
906/// - name: `AbsoluteTimeCounter`(ctype: `hkEnum<AbsoluteTimeCounter, hkUint32>`)
907#[allow(non_upper_case_globals, non_snake_case)]
908#[cfg_attr(feature = "json_schema", derive(schemars::JsonSchema))]
909#[cfg_attr(feature = "serde", derive(serde::Serialize, serde::Deserialize))]
910#[derive(
911    Debug,
912    Clone,
913    Default,
914    PartialEq,
915    Eq,
916    PartialOrd,
917    Ord,
918    num_derive::ToPrimitive,
919    num_derive::FromPrimitive,
920)]
921pub enum AbsoluteTimeCounter {
922    #[default]
923    ABSOLUTE_TIME_TIMER_0 = 0isize,
924    ABSOLUTE_TIME_TIMER_1 = 1isize,
925    ABSOLUTE_TIME_NOT_TIMED = -1isize,
926}
927const _: () = {
928    use havok_serde as __serde;
929    impl __serde::Serialize for AbsoluteTimeCounter {
930        fn serialize<S>(&self, __serializer: S) -> Result<S::Ok, S::Error>
931        where
932            S: __serde::ser::Serializer,
933        {
934            let mut __serializer = __serializer.serialize_enum_flags()?;
935            match self {
936                Self::ABSOLUTE_TIME_TIMER_0 => {
937                    __serializer.serialize_field("ABSOLUTE_TIME_TIMER_0", &0u64)
938                }
939                Self::ABSOLUTE_TIME_TIMER_1 => {
940                    __serializer.serialize_field("ABSOLUTE_TIME_TIMER_1", &1u64)
941                }
942                Self::ABSOLUTE_TIME_NOT_TIMED => {
943                    __serializer
944                        .serialize_field(
945                            "ABSOLUTE_TIME_NOT_TIMED",
946                            &18446744073709551615u64,
947                        )
948                }
949            }?;
950            use num_traits::ToPrimitive as _;
951            let num = self
952                .to_u32()
953                .ok_or(S::Error::custom("Failed enum AbsoluteTimeCounter to_u32"))?;
954            __serializer.serialize_bits(&num)?;
955            __serializer.end()
956        }
957    }
958};
959#[doc(hidden)]
960#[allow(non_upper_case_globals, unused_attributes, unused_qualifications)]
961const _: () = {
962    #[allow(unused_extern_crates, clippy::useless_attribute)]
963    extern crate havok_serde as _serde;
964    #[automatically_derived]
965    impl<'de> _serde::Deserialize<'de> for AbsoluteTimeCounter {
966        fn deserialize<__D>(
967            __deserializer: __D,
968        ) -> _serde::__private::Result<Self, __D::Error>
969        where
970            __D: _serde::Deserializer<'de>,
971        {
972            #[allow(non_camel_case_types)]
973            #[doc(hidden)]
974            enum __Field {
975                __field0,
976                __field1,
977                __field2,
978            }
979            #[doc(hidden)]
980            struct __FieldVisitor;
981            impl<'de> _serde::de::Visitor<'de> for __FieldVisitor {
982                type Value = __Field;
983                fn expecting(
984                    &self,
985                    __formatter: &mut _serde::__private::Formatter,
986                ) -> _serde::__private::fmt::Result {
987                    _serde::__private::Formatter::write_str(
988                        __formatter,
989                        "variant identifier",
990                    )
991                }
992                fn visit_uint32<__E>(
993                    self,
994                    __value: u32,
995                ) -> _serde::__private::Result<Self::Value, __E>
996                where
997                    __E: _serde::de::Error,
998                {
999                    match __value {
1000                        0u32 => _serde::__private::Ok(__Field::__field0),
1001                        1u32 => _serde::__private::Ok(__Field::__field1),
1002                        4294967295u32 => _serde::__private::Ok(__Field::__field2),
1003                        _ => {
1004                            _serde::__private::Err(
1005                                _serde::de::Error::invalid_value(
1006                                    _serde::de::Unexpected::Uint32(__value),
1007                                    &"value(u32) of variant is one of 0, 1, -1",
1008                                ),
1009                            )
1010                        }
1011                    }
1012                }
1013                fn visit_stringptr<__E>(
1014                    self,
1015                    __value: StringPtr<'de>,
1016                ) -> _serde::__private::Result<Self::Value, __E>
1017                where
1018                    __E: _serde::de::Error,
1019                {
1020                    if let Some(__value) = __value.into_inner() {
1021                        match __value.as_ref() {
1022                            v if v == "0"
1023                                || v.eq_ignore_ascii_case("ABSOLUTE_TIME_TIMER_0") => {
1024                                _serde::__private::Ok(__Field::__field0)
1025                            }
1026                            v if v == "1"
1027                                || v.eq_ignore_ascii_case("ABSOLUTE_TIME_TIMER_1") => {
1028                                _serde::__private::Ok(__Field::__field1)
1029                            }
1030                            v if v == "-1"
1031                                || v.eq_ignore_ascii_case("ABSOLUTE_TIME_NOT_TIMED") => {
1032                                _serde::__private::Ok(__Field::__field2)
1033                            }
1034                            _ => {
1035                                _serde::__private::Err(
1036                                    _serde::de::Error::unknown_variant(&__value, VARIANTS),
1037                                )
1038                            }
1039                        }
1040                    } else {
1041                        _serde::__private::Err(
1042                            _serde::de::Error::unknown_variant("None", VARIANTS),
1043                        )
1044                    }
1045                }
1046            }
1047            impl<'de> _serde::Deserialize<'de> for __Field {
1048                #[inline]
1049                fn deserialize<__D>(
1050                    __deserializer: __D,
1051                ) -> _serde::__private::Result<Self, __D::Error>
1052                where
1053                    __D: _serde::Deserializer<'de>,
1054                {
1055                    _serde::Deserializer::deserialize_identifier(
1056                        __deserializer,
1057                        _serde::de::ReadEnumSize::Uint32,
1058                        __FieldVisitor,
1059                    )
1060                }
1061            }
1062            #[doc(hidden)]
1063            struct __Visitor<'de> {
1064                marker: _serde::__private::PhantomData<AbsoluteTimeCounter>,
1065                lifetime: _serde::__private::PhantomData<&'de ()>,
1066            }
1067            impl<'de> _serde::de::Visitor<'de> for __Visitor<'de> {
1068                type Value = AbsoluteTimeCounter;
1069                fn expecting(
1070                    &self,
1071                    __formatter: &mut _serde::__private::Formatter,
1072                ) -> _serde::__private::fmt::Result {
1073                    _serde::__private::Formatter::write_str(
1074                        __formatter,
1075                        "enum AbsoluteTimeCounter",
1076                    )
1077                }
1078                fn visit_enum<__A>(
1079                    self,
1080                    __data: __A,
1081                ) -> _serde::__private::Result<Self::Value, __A::Error>
1082                where
1083                    __A: _serde::de::EnumAccess<'de>,
1084                {
1085                    match _serde::de::EnumAccess::variant(__data)? {
1086                        (__Field::__field0, __variant) => {
1087                            _serde::de::VariantAccess::unit_variant(__variant)?;
1088                            _serde::__private::Ok(
1089                                AbsoluteTimeCounter::ABSOLUTE_TIME_TIMER_0,
1090                            )
1091                        }
1092                        (__Field::__field1, __variant) => {
1093                            _serde::de::VariantAccess::unit_variant(__variant)?;
1094                            _serde::__private::Ok(
1095                                AbsoluteTimeCounter::ABSOLUTE_TIME_TIMER_1,
1096                            )
1097                        }
1098                        (__Field::__field2, __variant) => {
1099                            _serde::de::VariantAccess::unit_variant(__variant)?;
1100                            _serde::__private::Ok(
1101                                AbsoluteTimeCounter::ABSOLUTE_TIME_NOT_TIMED,
1102                            )
1103                        }
1104                    }
1105                }
1106            }
1107            #[doc(hidden)]
1108            const VARIANTS: &'static [&'static str] = &[
1109                "ABSOLUTE_TIME_TIMER_0",
1110                "ABSOLUTE_TIME_TIMER_1",
1111                "ABSOLUTE_TIME_NOT_TIMED",
1112            ];
1113            _serde::Deserializer::deserialize_enum(
1114                __deserializer,
1115                "AbsoluteTimeCounter",
1116                VARIANTS,
1117                __Visitor {
1118                    marker: _serde::__private::PhantomData::<AbsoluteTimeCounter>,
1119                    lifetime: _serde::__private::PhantomData,
1120                },
1121            )
1122        }
1123    }
1124};