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