1use super::class_requires::*;
2use super::*;
3#[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 #[cfg_attr(
22 feature = "serde",
23 serde(skip_serializing_if = "Option::is_none", default)
24 )]
25 pub __ptr: Option<Pointer>,
26 #[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 #[cfg_attr(feature = "json_schema", schemars(rename = "indexOfTimer0"))]
39 #[cfg_attr(feature = "serde", serde(rename = "indexOfTimer0"))]
40 pub m_indexOfTimer0: i32,
41 #[cfg_attr(feature = "json_schema", schemars(rename = "indexOfTimer1"))]
46 #[cfg_attr(feature = "serde", serde(rename = "indexOfTimer1"))]
47 pub m_indexOfTimer1: i32,
48 #[cfg_attr(feature = "json_schema", schemars(rename = "absoluteTimeCounter"))]
53 #[cfg_attr(feature = "serde", serde(rename = "absoluteTimeCounter"))]
54 pub m_absoluteTimeCounter: AbsoluteTimeCounter,
55 #[cfg_attr(feature = "json_schema", schemars(rename = "timerFactor0"))]
60 #[cfg_attr(feature = "serde", serde(rename = "timerFactor0"))]
61 pub m_timerFactor0: f32,
62 #[cfg_attr(feature = "json_schema", schemars(rename = "timerFactor1"))]
67 #[cfg_attr(feature = "serde", serde(rename = "timerFactor1"))]
68 pub m_timerFactor1: f32,
69 #[cfg_attr(feature = "json_schema", schemars(rename = "threadId"))]
74 #[cfg_attr(feature = "serde", serde(rename = "threadId"))]
75 pub m_threadId: i32,
76 #[cfg_attr(feature = "json_schema", schemars(rename = "frameStreamStart"))]
81 #[cfg_attr(feature = "serde", serde(rename = "frameStreamStart"))]
82 pub m_frameStreamStart: i32,
83 #[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 #[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#[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};