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 hkpConstraintInstance<'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 pub parent: hkReferencedObject,
30 #[cfg_attr(feature = "json_schema", schemars(rename = "owner"))]
36 #[cfg_attr(feature = "serde", serde(rename = "owner"))]
37 pub m_owner: Pointer,
38 #[cfg_attr(feature = "json_schema", schemars(rename = "data"))]
43 #[cfg_attr(feature = "serde", serde(rename = "data"))]
44 pub m_data: Pointer,
45 #[cfg_attr(feature = "json_schema", schemars(rename = "constraintModifiers"))]
50 #[cfg_attr(feature = "serde", serde(rename = "constraintModifiers"))]
51 pub m_constraintModifiers: Pointer,
52 #[cfg_attr(feature = "json_schema", schemars(rename = "entities"))]
57 #[cfg_attr(feature = "serde", serde(rename = "entities"))]
58 pub m_entities: [Pointer; 2usize],
59 #[cfg_attr(feature = "json_schema", schemars(rename = "priority"))]
64 #[cfg_attr(feature = "serde", serde(rename = "priority"))]
65 pub m_priority: ConstraintPriority,
66 #[cfg_attr(feature = "json_schema", schemars(rename = "wantRuntime"))]
71 #[cfg_attr(feature = "serde", serde(rename = "wantRuntime"))]
72 pub m_wantRuntime: bool,
73 #[cfg_attr(feature = "json_schema", schemars(rename = "destructionRemapInfo"))]
78 #[cfg_attr(feature = "serde", serde(rename = "destructionRemapInfo"))]
79 pub m_destructionRemapInfo: OnDestructionRemapInfo,
80 #[cfg_attr(feature = "json_schema", schemars(rename = "listeners"))]
86 #[cfg_attr(feature = "serde", serde(rename = "listeners"))]
87 pub m_listeners: hkpConstraintInstanceSmallArraySerializeOverrideType,
88 #[cfg_attr(feature = "serde", serde(borrow))]
93 #[cfg_attr(feature = "json_schema", schemars(rename = "name"))]
94 #[cfg_attr(feature = "serde", serde(rename = "name"))]
95 pub m_name: StringPtr<'a>,
96 #[cfg_attr(feature = "json_schema", schemars(rename = "userData"))]
101 #[cfg_attr(feature = "serde", serde(rename = "userData"))]
102 pub m_userData: Ulong,
103 #[cfg_attr(feature = "json_schema", schemars(rename = "internal"))]
109 #[cfg_attr(feature = "serde", serde(rename = "internal"))]
110 pub m_internal: Pointer,
111 #[cfg_attr(feature = "json_schema", schemars(rename = "uid"))]
117 #[cfg_attr(feature = "serde", serde(rename = "uid"))]
118 pub m_uid: u32,
119}
120const _: () = {
121 use havok_serde as _serde;
122 impl<'a> _serde::HavokClass for hkpConstraintInstance<'a> {
123 #[inline]
124 fn name(&self) -> &'static str {
125 "hkpConstraintInstance"
126 }
127 #[inline]
128 fn signature(&self) -> _serde::__private::Signature {
129 _serde::__private::Signature::new(0x34eba5f)
130 }
131 #[allow(clippy::let_and_return, clippy::vec_init_then_push)]
132 fn deps_indexes(&self) -> Vec<usize> {
133 let mut v = Vec::new();
134 v.push(self.m_owner.get());
135 v.push(self.m_data.get());
136 v.push(self.m_constraintModifiers.get());
137 v.extend(self.m_entities.iter().map(|ptr| ptr.get()));
138 v.extend(self.m_listeners.deps_indexes());
139 v.push(self.m_internal.get());
140 v
141 }
142 }
143 impl<'a> _serde::Serialize for hkpConstraintInstance<'a> {
144 fn serialize<S>(&self, __serializer: S) -> Result<S::Ok, S::Error>
145 where
146 S: _serde::ser::Serializer,
147 {
148 let class_meta = self
149 .__ptr
150 .map(|name| (name, _serde::__private::Signature::new(0x34eba5f)));
151 let mut serializer = __serializer
152 .serialize_struct("hkpConstraintInstance", class_meta, (56u64, 112u64))?;
153 serializer.pad_field([0u8; 4usize].as_slice(), [0u8; 8usize].as_slice())?;
154 serializer.skip_field("memSizeAndFlags", &self.parent.m_memSizeAndFlags)?;
155 serializer.skip_field("referenceCount", &self.parent.m_referenceCount)?;
156 serializer.pad_field([0u8; 0usize].as_slice(), [0u8; 4usize].as_slice())?;
157 serializer.skip_field("owner", &self.m_owner)?;
158 serializer.serialize_field("data", &self.m_data)?;
159 serializer
160 .serialize_field("constraintModifiers", &self.m_constraintModifiers)?;
161 serializer
162 .serialize_fixed_array_field(
163 "entities",
164 self.m_entities.as_slice(),
165 TypeSize::NonPtr,
166 )?;
167 serializer.serialize_field("priority", &self.m_priority)?;
168 serializer.serialize_field("wantRuntime", &self.m_wantRuntime)?;
169 serializer
170 .serialize_field("destructionRemapInfo", &self.m_destructionRemapInfo)?;
171 serializer.pad_field([0u8; 1usize].as_slice(), [0u8; 5usize].as_slice())?;
172 serializer.skip_field("listeners", &self.m_listeners)?;
173 serializer.serialize_field("name", &self.m_name)?;
174 serializer.serialize_field("userData", &self.m_userData)?;
175 serializer.skip_field("internal", &self.m_internal)?;
176 serializer.skip_field("uid", &self.m_uid)?;
177 serializer.pad_field([0u8; 0usize].as_slice(), [0u8; 4usize].as_slice())?;
178 serializer.end()
179 }
180 }
181};
182#[doc(hidden)]
183#[allow(non_upper_case_globals, unused_attributes, unused_qualifications)]
184const _: () = {
185 use havok_serde as _serde;
186 #[automatically_derived]
187 impl<'de> _serde::Deserialize<'de> for hkpConstraintInstance<'de> {
188 fn deserialize<__D>(deserializer: __D) -> core::result::Result<Self, __D::Error>
189 where
190 __D: _serde::Deserializer<'de>,
191 {
192 #[allow(non_camel_case_types)]
193 enum __Field {
194 m_data,
195 m_constraintModifiers,
196 m_entities,
197 m_priority,
198 m_wantRuntime,
199 m_destructionRemapInfo,
200 m_name,
201 m_userData,
202 __ignore,
203 }
204 struct __FieldVisitor;
205 impl<'de> _serde::de::Visitor<'de> for __FieldVisitor {
206 type Value = __Field;
207 fn expecting(
208 &self,
209 __formatter: &mut core::fmt::Formatter,
210 ) -> core::fmt::Result {
211 core::fmt::Formatter::write_str(__formatter, "field identifier")
212 }
213 #[allow(clippy::match_single_binding)]
215 #[allow(clippy::reversed_empty_ranges)]
216 #[allow(clippy::single_match)]
217 fn visit_key<__E>(
218 self,
219 __value: &str,
220 ) -> core::result::Result<Self::Value, __E>
221 where
222 __E: _serde::de::Error,
223 {
224 match __value {
225 "data" => Ok(__Field::m_data),
226 "constraintModifiers" => Ok(__Field::m_constraintModifiers),
227 "entities" => Ok(__Field::m_entities),
228 "priority" => Ok(__Field::m_priority),
229 "wantRuntime" => Ok(__Field::m_wantRuntime),
230 "destructionRemapInfo" => Ok(__Field::m_destructionRemapInfo),
231 "name" => Ok(__Field::m_name),
232 "userData" => Ok(__Field::m_userData),
233 _ => Ok(__Field::__ignore),
234 }
235 }
236 }
237 impl<'de> _serde::Deserialize<'de> for __Field {
238 #[inline]
239 fn deserialize<__D>(
240 __deserializer: __D,
241 ) -> core::result::Result<Self, __D::Error>
242 where
243 __D: _serde::Deserializer<'de>,
244 {
245 _serde::Deserializer::deserialize_key(__deserializer, __FieldVisitor)
246 }
247 }
248 struct __hkpConstraintInstanceVisitor<'de> {
249 marker: _serde::__private::PhantomData<hkpConstraintInstance<'de>>,
250 lifetime: _serde::__private::PhantomData<&'de ()>,
251 }
252 #[allow(clippy::match_single_binding)]
253 #[allow(clippy::reversed_empty_ranges)]
254 #[allow(clippy::single_match)]
255 impl<'de> _serde::de::Visitor<'de> for __hkpConstraintInstanceVisitor<'de> {
256 type Value = hkpConstraintInstance<'de>;
257 fn expecting(
258 &self,
259 __formatter: &mut core::fmt::Formatter,
260 ) -> core::fmt::Result {
261 core::fmt::Formatter::write_str(
262 __formatter,
263 "struct hkpConstraintInstance",
264 )
265 }
266 fn visit_struct_for_bytes<__A>(
267 self,
268 mut __map: __A,
269 ) -> _serde::__private::Result<Self::Value, __A::Error>
270 where
271 __A: _serde::de::MapAccess<'de>,
272 {
273 let __ptr = __A::class_ptr(&mut __map);
274 let parent = __A::parent_value(&mut __map)?;
275 let mut m_owner: _serde::__private::Option<Pointer> = _serde::__private::None;
276 let mut m_data: _serde::__private::Option<Pointer> = _serde::__private::None;
277 let mut m_constraintModifiers: _serde::__private::Option<Pointer> = _serde::__private::None;
278 let mut m_entities: _serde::__private::Option<[Pointer; 2usize]> = _serde::__private::None;
279 let mut m_priority: _serde::__private::Option<ConstraintPriority> = _serde::__private::None;
280 let mut m_wantRuntime: _serde::__private::Option<bool> = _serde::__private::None;
281 let mut m_destructionRemapInfo: _serde::__private::Option<
282 OnDestructionRemapInfo,
283 > = _serde::__private::None;
284 let mut m_listeners: _serde::__private::Option<
285 hkpConstraintInstanceSmallArraySerializeOverrideType,
286 > = _serde::__private::None;
287 let mut m_name: _serde::__private::Option<StringPtr<'de>> = _serde::__private::None;
288 let mut m_userData: _serde::__private::Option<Ulong> = _serde::__private::None;
289 let mut m_internal: _serde::__private::Option<Pointer> = _serde::__private::None;
290 let mut m_uid: _serde::__private::Option<u32> = _serde::__private::None;
291 for i in 0..12usize {
292 match i {
293 0usize => {
294 if _serde::__private::Option::is_some(&m_owner) {
295 return _serde::__private::Err(
296 <__A::Error as _serde::de::Error>::duplicate_field("owner"),
297 );
298 }
299 m_owner = _serde::__private::Some(
300 match __A::next_value::<Pointer>(&mut __map) {
301 _serde::__private::Ok(__val) => __val,
302 _serde::__private::Err(__err) => {
303 return _serde::__private::Err(__err);
304 }
305 },
306 );
307 }
308 1usize => {
309 if _serde::__private::Option::is_some(&m_data) {
310 return _serde::__private::Err(
311 <__A::Error as _serde::de::Error>::duplicate_field("data"),
312 );
313 }
314 m_data = _serde::__private::Some(
315 match __A::next_value::<Pointer>(&mut __map) {
316 _serde::__private::Ok(__val) => __val,
317 _serde::__private::Err(__err) => {
318 return _serde::__private::Err(__err);
319 }
320 },
321 );
322 }
323 2usize => {
324 if _serde::__private::Option::is_some(
325 &m_constraintModifiers,
326 ) {
327 return _serde::__private::Err(
328 <__A::Error as _serde::de::Error>::duplicate_field(
329 "constraintModifiers",
330 ),
331 );
332 }
333 m_constraintModifiers = _serde::__private::Some(
334 match __A::next_value::<Pointer>(&mut __map) {
335 _serde::__private::Ok(__val) => __val,
336 _serde::__private::Err(__err) => {
337 return _serde::__private::Err(__err);
338 }
339 },
340 );
341 }
342 3usize => {
343 if _serde::__private::Option::is_some(&m_entities) {
344 return _serde::__private::Err(
345 <__A::Error as _serde::de::Error>::duplicate_field(
346 "entities",
347 ),
348 );
349 }
350 m_entities = _serde::__private::Some(
351 match __A::next_value::<[Pointer; 2usize]>(&mut __map) {
352 _serde::__private::Ok(__val) => __val,
353 _serde::__private::Err(__err) => {
354 return _serde::__private::Err(__err);
355 }
356 },
357 );
358 }
359 4usize => {
360 if _serde::__private::Option::is_some(&m_priority) {
361 return _serde::__private::Err(
362 <__A::Error as _serde::de::Error>::duplicate_field(
363 "priority",
364 ),
365 );
366 }
367 m_priority = _serde::__private::Some(
368 match __A::next_value::<ConstraintPriority>(&mut __map) {
369 _serde::__private::Ok(__val) => __val,
370 _serde::__private::Err(__err) => {
371 return _serde::__private::Err(__err);
372 }
373 },
374 );
375 }
376 5usize => {
377 if _serde::__private::Option::is_some(&m_wantRuntime) {
378 return _serde::__private::Err(
379 <__A::Error as _serde::de::Error>::duplicate_field(
380 "wantRuntime",
381 ),
382 );
383 }
384 m_wantRuntime = _serde::__private::Some(
385 match __A::next_value::<bool>(&mut __map) {
386 _serde::__private::Ok(__val) => __val,
387 _serde::__private::Err(__err) => {
388 return _serde::__private::Err(__err);
389 }
390 },
391 );
392 }
393 6usize => {
394 if _serde::__private::Option::is_some(
395 &m_destructionRemapInfo,
396 ) {
397 return _serde::__private::Err(
398 <__A::Error as _serde::de::Error>::duplicate_field(
399 "destructionRemapInfo",
400 ),
401 );
402 }
403 m_destructionRemapInfo = _serde::__private::Some(
404 match __A::next_value::<
405 OnDestructionRemapInfo,
406 >(&mut __map) {
407 _serde::__private::Ok(__val) => __val,
408 _serde::__private::Err(__err) => {
409 return _serde::__private::Err(__err);
410 }
411 },
412 );
413 }
414 7usize => {
415 if _serde::__private::Option::is_some(&m_listeners) {
416 return _serde::__private::Err(
417 <__A::Error as _serde::de::Error>::duplicate_field(
418 "listeners",
419 ),
420 );
421 }
422 __A::pad(&mut __map, 1usize, 5usize)?;
423 m_listeners = _serde::__private::Some(
424 match __A::next_value::<
425 hkpConstraintInstanceSmallArraySerializeOverrideType,
426 >(&mut __map) {
427 _serde::__private::Ok(__val) => __val,
428 _serde::__private::Err(__err) => {
429 return _serde::__private::Err(__err);
430 }
431 },
432 );
433 }
434 8usize => {
435 if _serde::__private::Option::is_some(&m_name) {
436 return _serde::__private::Err(
437 <__A::Error as _serde::de::Error>::duplicate_field("name"),
438 );
439 }
440 m_name = _serde::__private::Some(
441 match __A::next_value::<StringPtr<'de>>(&mut __map) {
442 _serde::__private::Ok(__val) => __val,
443 _serde::__private::Err(__err) => {
444 return _serde::__private::Err(__err);
445 }
446 },
447 );
448 }
449 9usize => {
450 if _serde::__private::Option::is_some(&m_userData) {
451 return _serde::__private::Err(
452 <__A::Error as _serde::de::Error>::duplicate_field(
453 "userData",
454 ),
455 );
456 }
457 m_userData = _serde::__private::Some(
458 match __A::next_value::<Ulong>(&mut __map) {
459 _serde::__private::Ok(__val) => __val,
460 _serde::__private::Err(__err) => {
461 return _serde::__private::Err(__err);
462 }
463 },
464 );
465 }
466 10usize => {
467 if _serde::__private::Option::is_some(&m_internal) {
468 return _serde::__private::Err(
469 <__A::Error as _serde::de::Error>::duplicate_field(
470 "internal",
471 ),
472 );
473 }
474 m_internal = _serde::__private::Some(
475 match __A::next_value::<Pointer>(&mut __map) {
476 _serde::__private::Ok(__val) => __val,
477 _serde::__private::Err(__err) => {
478 return _serde::__private::Err(__err);
479 }
480 },
481 );
482 }
483 11usize => {
484 if _serde::__private::Option::is_some(&m_uid) {
485 return _serde::__private::Err(
486 <__A::Error as _serde::de::Error>::duplicate_field("uid"),
487 );
488 }
489 m_uid = _serde::__private::Some(
490 match __A::next_value::<u32>(&mut __map) {
491 _serde::__private::Ok(__val) => __val,
492 _serde::__private::Err(__err) => {
493 return _serde::__private::Err(__err);
494 }
495 },
496 );
497 }
498 _ => {}
499 }
500 }
501 __A::pad(&mut __map, 0usize, 4usize)?;
502 let m_owner = match m_owner {
503 _serde::__private::Some(__field) => __field,
504 _serde::__private::None => {
505 return _serde::__private::Err(
506 <__A::Error as _serde::de::Error>::missing_field("owner"),
507 );
508 }
509 };
510 let m_data = match m_data {
511 _serde::__private::Some(__field) => __field,
512 _serde::__private::None => {
513 return _serde::__private::Err(
514 <__A::Error as _serde::de::Error>::missing_field("data"),
515 );
516 }
517 };
518 let m_constraintModifiers = match m_constraintModifiers {
519 _serde::__private::Some(__field) => __field,
520 _serde::__private::None => {
521 return _serde::__private::Err(
522 <__A::Error as _serde::de::Error>::missing_field(
523 "constraintModifiers",
524 ),
525 );
526 }
527 };
528 let m_entities = match m_entities {
529 _serde::__private::Some(__field) => __field,
530 _serde::__private::None => {
531 return _serde::__private::Err(
532 <__A::Error as _serde::de::Error>::missing_field("entities"),
533 );
534 }
535 };
536 let m_priority = match m_priority {
537 _serde::__private::Some(__field) => __field,
538 _serde::__private::None => {
539 return _serde::__private::Err(
540 <__A::Error as _serde::de::Error>::missing_field("priority"),
541 );
542 }
543 };
544 let m_wantRuntime = match m_wantRuntime {
545 _serde::__private::Some(__field) => __field,
546 _serde::__private::None => {
547 return _serde::__private::Err(
548 <__A::Error as _serde::de::Error>::missing_field(
549 "wantRuntime",
550 ),
551 );
552 }
553 };
554 let m_destructionRemapInfo = match m_destructionRemapInfo {
555 _serde::__private::Some(__field) => __field,
556 _serde::__private::None => {
557 return _serde::__private::Err(
558 <__A::Error as _serde::de::Error>::missing_field(
559 "destructionRemapInfo",
560 ),
561 );
562 }
563 };
564 let m_listeners = match m_listeners {
565 _serde::__private::Some(__field) => __field,
566 _serde::__private::None => {
567 return _serde::__private::Err(
568 <__A::Error as _serde::de::Error>::missing_field(
569 "listeners",
570 ),
571 );
572 }
573 };
574 let m_name = match m_name {
575 _serde::__private::Some(__field) => __field,
576 _serde::__private::None => {
577 return _serde::__private::Err(
578 <__A::Error as _serde::de::Error>::missing_field("name"),
579 );
580 }
581 };
582 let m_userData = match m_userData {
583 _serde::__private::Some(__field) => __field,
584 _serde::__private::None => {
585 return _serde::__private::Err(
586 <__A::Error as _serde::de::Error>::missing_field("userData"),
587 );
588 }
589 };
590 let m_internal = match m_internal {
591 _serde::__private::Some(__field) => __field,
592 _serde::__private::None => {
593 return _serde::__private::Err(
594 <__A::Error as _serde::de::Error>::missing_field("internal"),
595 );
596 }
597 };
598 let m_uid = match m_uid {
599 _serde::__private::Some(__field) => __field,
600 _serde::__private::None => {
601 return _serde::__private::Err(
602 <__A::Error as _serde::de::Error>::missing_field("uid"),
603 );
604 }
605 };
606 _serde::__private::Ok(hkpConstraintInstance {
607 __ptr,
608 parent,
609 m_owner,
610 m_data,
611 m_constraintModifiers,
612 m_entities,
613 m_priority,
614 m_wantRuntime,
615 m_destructionRemapInfo,
616 m_listeners,
617 m_name,
618 m_userData,
619 m_internal,
620 m_uid,
621 })
622 }
623 #[allow(clippy::manual_unwrap_or_default)]
624 fn visit_struct<__A>(
625 self,
626 mut __map: __A,
627 ) -> _serde::__private::Result<Self::Value, __A::Error>
628 where
629 __A: _serde::de::MapAccess<'de>,
630 {
631 let mut m_data: _serde::__private::Option<Pointer> = _serde::__private::None;
632 let mut m_constraintModifiers: _serde::__private::Option<Pointer> = _serde::__private::None;
633 let mut m_entities: _serde::__private::Option<[Pointer; 2usize]> = _serde::__private::None;
634 let mut m_priority: _serde::__private::Option<ConstraintPriority> = _serde::__private::None;
635 let mut m_wantRuntime: _serde::__private::Option<bool> = _serde::__private::None;
636 let mut m_destructionRemapInfo: _serde::__private::Option<
637 OnDestructionRemapInfo,
638 > = _serde::__private::None;
639 let mut m_name: _serde::__private::Option<StringPtr<'de>> = _serde::__private::None;
640 let mut m_userData: _serde::__private::Option<Ulong> = _serde::__private::None;
641 while let _serde::__private::Some(__key) = {
642 __A::next_key::<__Field>(&mut __map)?
643 } {
644 match __key {
645 __Field::m_data => {
646 #[cfg(
647 any(feature = "strict", feature = "ignore_duplicates")
648 )]
649 if _serde::__private::Option::is_some(&m_data) {
650 #[cfg(feature = "ignore_duplicates")]
651 {
652 __A::skip_value(&mut __map)?;
653 continue;
654 }
655 #[cfg(feature = "strict")]
656 return _serde::__private::Err(
657 <__A::Error as _serde::de::Error>::duplicate_field("data"),
658 );
659 }
660 m_data = _serde::__private::Some(
661 match __A::next_value::<Pointer>(&mut __map) {
662 _serde::__private::Ok(__val) => __val,
663 _serde::__private::Err(__err) => {
664 return _serde::__private::Err(__err);
665 }
666 },
667 );
668 }
669 __Field::m_constraintModifiers => {
670 #[cfg(
671 any(feature = "strict", feature = "ignore_duplicates")
672 )]
673 if _serde::__private::Option::is_some(
674 &m_constraintModifiers,
675 ) {
676 #[cfg(feature = "ignore_duplicates")]
677 {
678 __A::skip_value(&mut __map)?;
679 continue;
680 }
681 #[cfg(feature = "strict")]
682 return _serde::__private::Err(
683 <__A::Error as _serde::de::Error>::duplicate_field(
684 "constraintModifiers",
685 ),
686 );
687 }
688 m_constraintModifiers = _serde::__private::Some(
689 match __A::next_value::<Pointer>(&mut __map) {
690 _serde::__private::Ok(__val) => __val,
691 _serde::__private::Err(__err) => {
692 return _serde::__private::Err(__err);
693 }
694 },
695 );
696 }
697 __Field::m_entities => {
698 #[cfg(
699 any(feature = "strict", feature = "ignore_duplicates")
700 )]
701 if _serde::__private::Option::is_some(&m_entities) {
702 #[cfg(feature = "ignore_duplicates")]
703 {
704 __A::skip_value(&mut __map)?;
705 continue;
706 }
707 #[cfg(feature = "strict")]
708 return _serde::__private::Err(
709 <__A::Error as _serde::de::Error>::duplicate_field(
710 "entities",
711 ),
712 );
713 }
714 m_entities = _serde::__private::Some(
715 match __A::next_value::<[Pointer; 2usize]>(&mut __map) {
716 _serde::__private::Ok(__val) => __val,
717 _serde::__private::Err(__err) => {
718 return _serde::__private::Err(__err);
719 }
720 },
721 );
722 }
723 __Field::m_priority => {
724 #[cfg(
725 any(feature = "strict", feature = "ignore_duplicates")
726 )]
727 if _serde::__private::Option::is_some(&m_priority) {
728 #[cfg(feature = "ignore_duplicates")]
729 {
730 __A::skip_value(&mut __map)?;
731 continue;
732 }
733 #[cfg(feature = "strict")]
734 return _serde::__private::Err(
735 <__A::Error as _serde::de::Error>::duplicate_field(
736 "priority",
737 ),
738 );
739 }
740 m_priority = _serde::__private::Some(
741 match __A::next_value::<ConstraintPriority>(&mut __map) {
742 _serde::__private::Ok(__val) => __val,
743 _serde::__private::Err(__err) => {
744 return _serde::__private::Err(__err);
745 }
746 },
747 );
748 }
749 __Field::m_wantRuntime => {
750 #[cfg(
751 any(feature = "strict", feature = "ignore_duplicates")
752 )]
753 if _serde::__private::Option::is_some(&m_wantRuntime) {
754 #[cfg(feature = "ignore_duplicates")]
755 {
756 __A::skip_value(&mut __map)?;
757 continue;
758 }
759 #[cfg(feature = "strict")]
760 return _serde::__private::Err(
761 <__A::Error as _serde::de::Error>::duplicate_field(
762 "wantRuntime",
763 ),
764 );
765 }
766 m_wantRuntime = _serde::__private::Some(
767 match __A::next_value::<bool>(&mut __map) {
768 _serde::__private::Ok(__val) => __val,
769 _serde::__private::Err(__err) => {
770 return _serde::__private::Err(__err);
771 }
772 },
773 );
774 }
775 __Field::m_destructionRemapInfo => {
776 #[cfg(
777 any(feature = "strict", feature = "ignore_duplicates")
778 )]
779 if _serde::__private::Option::is_some(
780 &m_destructionRemapInfo,
781 ) {
782 #[cfg(feature = "ignore_duplicates")]
783 {
784 __A::skip_value(&mut __map)?;
785 continue;
786 }
787 #[cfg(feature = "strict")]
788 return _serde::__private::Err(
789 <__A::Error as _serde::de::Error>::duplicate_field(
790 "destructionRemapInfo",
791 ),
792 );
793 }
794 m_destructionRemapInfo = _serde::__private::Some(
795 match __A::next_value::<
796 OnDestructionRemapInfo,
797 >(&mut __map) {
798 _serde::__private::Ok(__val) => __val,
799 _serde::__private::Err(__err) => {
800 return _serde::__private::Err(__err);
801 }
802 },
803 );
804 }
805 __Field::m_name => {
806 #[cfg(
807 any(feature = "strict", feature = "ignore_duplicates")
808 )]
809 if _serde::__private::Option::is_some(&m_name) {
810 #[cfg(feature = "ignore_duplicates")]
811 {
812 __A::skip_value(&mut __map)?;
813 continue;
814 }
815 #[cfg(feature = "strict")]
816 return _serde::__private::Err(
817 <__A::Error as _serde::de::Error>::duplicate_field("name"),
818 );
819 }
820 m_name = _serde::__private::Some(
821 match __A::next_value::<StringPtr<'de>>(&mut __map) {
822 _serde::__private::Ok(__val) => __val,
823 _serde::__private::Err(__err) => {
824 return _serde::__private::Err(__err);
825 }
826 },
827 );
828 }
829 __Field::m_userData => {
830 #[cfg(
831 any(feature = "strict", feature = "ignore_duplicates")
832 )]
833 if _serde::__private::Option::is_some(&m_userData) {
834 #[cfg(feature = "ignore_duplicates")]
835 {
836 __A::skip_value(&mut __map)?;
837 continue;
838 }
839 #[cfg(feature = "strict")]
840 return _serde::__private::Err(
841 <__A::Error as _serde::de::Error>::duplicate_field(
842 "userData",
843 ),
844 );
845 }
846 m_userData = _serde::__private::Some(
847 match __A::next_value::<Ulong>(&mut __map) {
848 _serde::__private::Ok(__val) => __val,
849 _serde::__private::Err(__err) => {
850 return _serde::__private::Err(__err);
851 }
852 },
853 );
854 }
855 _ => __A::skip_value(&mut __map)?,
856 }
857 }
858 let m_data = match m_data {
859 _serde::__private::Some(__field) => __field,
860 _serde::__private::None => {
861 #[cfg(feature = "strict")]
862 return _serde::__private::Err(
863 <__A::Error as _serde::de::Error>::missing_field("data"),
864 );
865 #[cfg(not(feature = "strict"))] Default::default()
866 }
867 };
868 let m_constraintModifiers = match m_constraintModifiers {
869 _serde::__private::Some(__field) => __field,
870 _serde::__private::None => {
871 #[cfg(feature = "strict")]
872 return _serde::__private::Err(
873 <__A::Error as _serde::de::Error>::missing_field(
874 "constraintModifiers",
875 ),
876 );
877 #[cfg(not(feature = "strict"))] Default::default()
878 }
879 };
880 let m_entities = match m_entities {
881 _serde::__private::Some(__field) => __field,
882 _serde::__private::None => {
883 #[cfg(feature = "strict")]
884 return _serde::__private::Err(
885 <__A::Error as _serde::de::Error>::missing_field("entities"),
886 );
887 #[cfg(not(feature = "strict"))] Default::default()
888 }
889 };
890 let m_priority = match m_priority {
891 _serde::__private::Some(__field) => __field,
892 _serde::__private::None => {
893 #[cfg(feature = "strict")]
894 return _serde::__private::Err(
895 <__A::Error as _serde::de::Error>::missing_field("priority"),
896 );
897 #[cfg(not(feature = "strict"))] Default::default()
898 }
899 };
900 let m_wantRuntime = match m_wantRuntime {
901 _serde::__private::Some(__field) => __field,
902 _serde::__private::None => {
903 #[cfg(feature = "strict")]
904 return _serde::__private::Err(
905 <__A::Error as _serde::de::Error>::missing_field(
906 "wantRuntime",
907 ),
908 );
909 #[cfg(not(feature = "strict"))] Default::default()
910 }
911 };
912 let m_destructionRemapInfo = match m_destructionRemapInfo {
913 _serde::__private::Some(__field) => __field,
914 _serde::__private::None => {
915 #[cfg(feature = "strict")]
916 return _serde::__private::Err(
917 <__A::Error as _serde::de::Error>::missing_field(
918 "destructionRemapInfo",
919 ),
920 );
921 #[cfg(not(feature = "strict"))] Default::default()
922 }
923 };
924 let m_name = match m_name {
925 _serde::__private::Some(__field) => __field,
926 _serde::__private::None => {
927 #[cfg(feature = "strict")]
928 return _serde::__private::Err(
929 <__A::Error as _serde::de::Error>::missing_field("name"),
930 );
931 #[cfg(not(feature = "strict"))] Default::default()
932 }
933 };
934 let m_userData = match m_userData {
935 _serde::__private::Some(__field) => __field,
936 _serde::__private::None => {
937 #[cfg(feature = "strict")]
938 return _serde::__private::Err(
939 <__A::Error as _serde::de::Error>::missing_field("userData"),
940 );
941 #[cfg(not(feature = "strict"))] Default::default()
942 }
943 };
944 let __ptr = None;
945 let parent = hkBaseObject { __ptr };
946 let parent = hkReferencedObject {
947 __ptr,
948 parent,
949 ..Default::default()
950 };
951 let __ptr = __A::class_ptr(&mut __map);
952 _serde::__private::Ok(hkpConstraintInstance {
953 __ptr,
954 parent,
955 m_data,
956 m_constraintModifiers,
957 m_entities,
958 m_priority,
959 m_wantRuntime,
960 m_destructionRemapInfo,
961 m_name,
962 m_userData,
963 ..Default::default()
964 })
965 }
966 }
967 const FIELDS: &[&str] = &[
968 "owner",
969 "data",
970 "constraintModifiers",
971 "entities",
972 "priority",
973 "wantRuntime",
974 "destructionRemapInfo",
975 "listeners",
976 "name",
977 "userData",
978 "internal",
979 "uid",
980 ];
981 _serde::Deserializer::deserialize_struct(
982 deserializer,
983 "hkpConstraintInstance",
984 FIELDS,
985 __hkpConstraintInstanceVisitor {
986 marker: _serde::__private::PhantomData::<hkpConstraintInstance>,
987 lifetime: _serde::__private::PhantomData,
988 },
989 )
990 }
991 }
992};
993#[allow(non_upper_case_globals, non_snake_case)]
996#[cfg_attr(feature = "json_schema", derive(schemars::JsonSchema))]
997#[cfg_attr(feature = "serde", derive(serde::Serialize, serde::Deserialize))]
998#[derive(
999 Debug,
1000 Clone,
1001 Default,
1002 PartialEq,
1003 Eq,
1004 PartialOrd,
1005 Ord,
1006 num_derive::ToPrimitive,
1007 num_derive::FromPrimitive,
1008)]
1009pub enum ConstraintPriority {
1010 #[default]
1011 PRIORITY_INVALID = 0isize,
1012 PRIORITY_PSI = 1isize,
1013 PRIORITY_SIMPLIFIED_TOI_UNUSED = 2isize,
1014 PRIORITY_TOI = 3isize,
1015 PRIORITY_TOI_HIGHER = 4isize,
1016 PRIORITY_TOI_FORCED = 5isize,
1017 NUM_PRIORITIES = 6isize,
1018}
1019#[allow(non_upper_case_globals, non_snake_case)]
1022#[cfg_attr(feature = "json_schema", derive(schemars::JsonSchema))]
1023#[cfg_attr(feature = "serde", derive(serde::Serialize, serde::Deserialize))]
1024#[derive(
1025 Debug,
1026 Clone,
1027 Default,
1028 PartialEq,
1029 Eq,
1030 PartialOrd,
1031 Ord,
1032 num_derive::ToPrimitive,
1033 num_derive::FromPrimitive,
1034)]
1035pub enum OnDestructionRemapInfo {
1036 #[default]
1037 ON_DESTRUCTION_REMAP = 0isize,
1038 ON_DESTRUCTION_REMOVE = 1isize,
1039 ON_DESTRUCTION_RESET_REMOVE = 2isize,
1040}
1041const _: () = {
1042 use havok_serde as __serde;
1043 impl __serde::Serialize for ConstraintPriority {
1044 fn serialize<S>(&self, __serializer: S) -> Result<S::Ok, S::Error>
1045 where
1046 S: __serde::ser::Serializer,
1047 {
1048 let mut __serializer = __serializer.serialize_enum_flags()?;
1049 match self {
1050 Self::PRIORITY_INVALID => {
1051 __serializer.serialize_field("PRIORITY_INVALID", &0u64)
1052 }
1053 Self::PRIORITY_PSI => __serializer.serialize_field("PRIORITY_PSI", &1u64),
1054 Self::PRIORITY_SIMPLIFIED_TOI_UNUSED => {
1055 __serializer.serialize_field("PRIORITY_SIMPLIFIED_TOI_UNUSED", &2u64)
1056 }
1057 Self::PRIORITY_TOI => __serializer.serialize_field("PRIORITY_TOI", &3u64),
1058 Self::PRIORITY_TOI_HIGHER => {
1059 __serializer.serialize_field("PRIORITY_TOI_HIGHER", &4u64)
1060 }
1061 Self::PRIORITY_TOI_FORCED => {
1062 __serializer.serialize_field("PRIORITY_TOI_FORCED", &5u64)
1063 }
1064 Self::NUM_PRIORITIES => {
1065 __serializer.serialize_field("NUM_PRIORITIES", &6u64)
1066 }
1067 }?;
1068 use num_traits::ToPrimitive as _;
1069 let num = self
1070 .to_u8()
1071 .ok_or(S::Error::custom("Failed enum ConstraintPriority to_u8"))?;
1072 __serializer.serialize_bits(&num)?;
1073 __serializer.end()
1074 }
1075 }
1076};
1077const _: () = {
1078 use havok_serde as __serde;
1079 impl __serde::Serialize for OnDestructionRemapInfo {
1080 fn serialize<S>(&self, __serializer: S) -> Result<S::Ok, S::Error>
1081 where
1082 S: __serde::ser::Serializer,
1083 {
1084 let mut __serializer = __serializer.serialize_enum_flags()?;
1085 match self {
1086 Self::ON_DESTRUCTION_REMAP => {
1087 __serializer.serialize_field("ON_DESTRUCTION_REMAP", &0u64)
1088 }
1089 Self::ON_DESTRUCTION_REMOVE => {
1090 __serializer.serialize_field("ON_DESTRUCTION_REMOVE", &1u64)
1091 }
1092 Self::ON_DESTRUCTION_RESET_REMOVE => {
1093 __serializer.serialize_field("ON_DESTRUCTION_RESET_REMOVE", &2u64)
1094 }
1095 }?;
1096 use num_traits::ToPrimitive as _;
1097 let num = self
1098 .to_u8()
1099 .ok_or(S::Error::custom("Failed enum OnDestructionRemapInfo to_u8"))?;
1100 __serializer.serialize_bits(&num)?;
1101 __serializer.end()
1102 }
1103 }
1104};
1105#[doc(hidden)]
1106#[allow(non_upper_case_globals, unused_attributes, unused_qualifications)]
1107const _: () = {
1108 #[allow(unused_extern_crates, clippy::useless_attribute)]
1109 extern crate havok_serde as _serde;
1110 #[automatically_derived]
1111 impl<'de> _serde::Deserialize<'de> for ConstraintPriority {
1112 fn deserialize<__D>(
1113 __deserializer: __D,
1114 ) -> _serde::__private::Result<Self, __D::Error>
1115 where
1116 __D: _serde::Deserializer<'de>,
1117 {
1118 #[allow(non_camel_case_types)]
1119 #[doc(hidden)]
1120 enum __Field {
1121 __field0,
1122 __field1,
1123 __field2,
1124 __field3,
1125 __field4,
1126 __field5,
1127 __field6,
1128 }
1129 #[doc(hidden)]
1130 struct __FieldVisitor;
1131 impl<'de> _serde::de::Visitor<'de> for __FieldVisitor {
1132 type Value = __Field;
1133 fn expecting(
1134 &self,
1135 __formatter: &mut _serde::__private::Formatter,
1136 ) -> _serde::__private::fmt::Result {
1137 _serde::__private::Formatter::write_str(
1138 __formatter,
1139 "variant identifier",
1140 )
1141 }
1142 fn visit_uint8<__E>(
1143 self,
1144 __value: u8,
1145 ) -> _serde::__private::Result<Self::Value, __E>
1146 where
1147 __E: _serde::de::Error,
1148 {
1149 match __value {
1150 0u8 => _serde::__private::Ok(__Field::__field0),
1151 1u8 => _serde::__private::Ok(__Field::__field1),
1152 2u8 => _serde::__private::Ok(__Field::__field2),
1153 3u8 => _serde::__private::Ok(__Field::__field3),
1154 4u8 => _serde::__private::Ok(__Field::__field4),
1155 5u8 => _serde::__private::Ok(__Field::__field5),
1156 6u8 => _serde::__private::Ok(__Field::__field6),
1157 _ => {
1158 _serde::__private::Err(
1159 _serde::de::Error::invalid_value(
1160 _serde::de::Unexpected::Uint8(__value),
1161 &"value(u8) of variant is one of 0, 1, 2, 3, 4, 5, 6",
1162 ),
1163 )
1164 }
1165 }
1166 }
1167 fn visit_stringptr<__E>(
1168 self,
1169 __value: StringPtr<'de>,
1170 ) -> _serde::__private::Result<Self::Value, __E>
1171 where
1172 __E: _serde::de::Error,
1173 {
1174 if let Some(__value) = __value.into_inner() {
1175 match __value.as_ref() {
1176 v if v == "0"
1177 || v.eq_ignore_ascii_case("PRIORITY_INVALID") => {
1178 _serde::__private::Ok(__Field::__field0)
1179 }
1180 v if v == "1" || v.eq_ignore_ascii_case("PRIORITY_PSI") => {
1181 _serde::__private::Ok(__Field::__field1)
1182 }
1183 v if v == "2"
1184 || v
1185 .eq_ignore_ascii_case("PRIORITY_SIMPLIFIED_TOI_UNUSED") => {
1186 _serde::__private::Ok(__Field::__field2)
1187 }
1188 v if v == "3" || v.eq_ignore_ascii_case("PRIORITY_TOI") => {
1189 _serde::__private::Ok(__Field::__field3)
1190 }
1191 v if v == "4"
1192 || v.eq_ignore_ascii_case("PRIORITY_TOI_HIGHER") => {
1193 _serde::__private::Ok(__Field::__field4)
1194 }
1195 v if v == "5"
1196 || v.eq_ignore_ascii_case("PRIORITY_TOI_FORCED") => {
1197 _serde::__private::Ok(__Field::__field5)
1198 }
1199 v if v == "6" || v.eq_ignore_ascii_case("NUM_PRIORITIES") => {
1200 _serde::__private::Ok(__Field::__field6)
1201 }
1202 _ => {
1203 _serde::__private::Err(
1204 _serde::de::Error::unknown_variant(&__value, VARIANTS),
1205 )
1206 }
1207 }
1208 } else {
1209 _serde::__private::Err(
1210 _serde::de::Error::unknown_variant("None", VARIANTS),
1211 )
1212 }
1213 }
1214 }
1215 impl<'de> _serde::Deserialize<'de> for __Field {
1216 #[inline]
1217 fn deserialize<__D>(
1218 __deserializer: __D,
1219 ) -> _serde::__private::Result<Self, __D::Error>
1220 where
1221 __D: _serde::Deserializer<'de>,
1222 {
1223 _serde::Deserializer::deserialize_identifier(
1224 __deserializer,
1225 _serde::de::ReadEnumSize::Uint8,
1226 __FieldVisitor,
1227 )
1228 }
1229 }
1230 #[doc(hidden)]
1231 struct __Visitor<'de> {
1232 marker: _serde::__private::PhantomData<ConstraintPriority>,
1233 lifetime: _serde::__private::PhantomData<&'de ()>,
1234 }
1235 impl<'de> _serde::de::Visitor<'de> for __Visitor<'de> {
1236 type Value = ConstraintPriority;
1237 fn expecting(
1238 &self,
1239 __formatter: &mut _serde::__private::Formatter,
1240 ) -> _serde::__private::fmt::Result {
1241 _serde::__private::Formatter::write_str(
1242 __formatter,
1243 "enum ConstraintPriority",
1244 )
1245 }
1246 fn visit_enum<__A>(
1247 self,
1248 __data: __A,
1249 ) -> _serde::__private::Result<Self::Value, __A::Error>
1250 where
1251 __A: _serde::de::EnumAccess<'de>,
1252 {
1253 match _serde::de::EnumAccess::variant(__data)? {
1254 (__Field::__field0, __variant) => {
1255 _serde::de::VariantAccess::unit_variant(__variant)?;
1256 _serde::__private::Ok(ConstraintPriority::PRIORITY_INVALID)
1257 }
1258 (__Field::__field1, __variant) => {
1259 _serde::de::VariantAccess::unit_variant(__variant)?;
1260 _serde::__private::Ok(ConstraintPriority::PRIORITY_PSI)
1261 }
1262 (__Field::__field2, __variant) => {
1263 _serde::de::VariantAccess::unit_variant(__variant)?;
1264 _serde::__private::Ok(
1265 ConstraintPriority::PRIORITY_SIMPLIFIED_TOI_UNUSED,
1266 )
1267 }
1268 (__Field::__field3, __variant) => {
1269 _serde::de::VariantAccess::unit_variant(__variant)?;
1270 _serde::__private::Ok(ConstraintPriority::PRIORITY_TOI)
1271 }
1272 (__Field::__field4, __variant) => {
1273 _serde::de::VariantAccess::unit_variant(__variant)?;
1274 _serde::__private::Ok(
1275 ConstraintPriority::PRIORITY_TOI_HIGHER,
1276 )
1277 }
1278 (__Field::__field5, __variant) => {
1279 _serde::de::VariantAccess::unit_variant(__variant)?;
1280 _serde::__private::Ok(
1281 ConstraintPriority::PRIORITY_TOI_FORCED,
1282 )
1283 }
1284 (__Field::__field6, __variant) => {
1285 _serde::de::VariantAccess::unit_variant(__variant)?;
1286 _serde::__private::Ok(ConstraintPriority::NUM_PRIORITIES)
1287 }
1288 }
1289 }
1290 }
1291 #[doc(hidden)]
1292 const VARIANTS: &'static [&'static str] = &[
1293 "PRIORITY_INVALID",
1294 "PRIORITY_PSI",
1295 "PRIORITY_SIMPLIFIED_TOI_UNUSED",
1296 "PRIORITY_TOI",
1297 "PRIORITY_TOI_HIGHER",
1298 "PRIORITY_TOI_FORCED",
1299 "NUM_PRIORITIES",
1300 ];
1301 _serde::Deserializer::deserialize_enum(
1302 __deserializer,
1303 "ConstraintPriority",
1304 VARIANTS,
1305 __Visitor {
1306 marker: _serde::__private::PhantomData::<ConstraintPriority>,
1307 lifetime: _serde::__private::PhantomData,
1308 },
1309 )
1310 }
1311 }
1312};
1313#[doc(hidden)]
1314#[allow(non_upper_case_globals, unused_attributes, unused_qualifications)]
1315const _: () = {
1316 #[allow(unused_extern_crates, clippy::useless_attribute)]
1317 extern crate havok_serde as _serde;
1318 #[automatically_derived]
1319 impl<'de> _serde::Deserialize<'de> for OnDestructionRemapInfo {
1320 fn deserialize<__D>(
1321 __deserializer: __D,
1322 ) -> _serde::__private::Result<Self, __D::Error>
1323 where
1324 __D: _serde::Deserializer<'de>,
1325 {
1326 #[allow(non_camel_case_types)]
1327 #[doc(hidden)]
1328 enum __Field {
1329 __field0,
1330 __field1,
1331 __field2,
1332 }
1333 #[doc(hidden)]
1334 struct __FieldVisitor;
1335 impl<'de> _serde::de::Visitor<'de> for __FieldVisitor {
1336 type Value = __Field;
1337 fn expecting(
1338 &self,
1339 __formatter: &mut _serde::__private::Formatter,
1340 ) -> _serde::__private::fmt::Result {
1341 _serde::__private::Formatter::write_str(
1342 __formatter,
1343 "variant identifier",
1344 )
1345 }
1346 fn visit_uint8<__E>(
1347 self,
1348 __value: u8,
1349 ) -> _serde::__private::Result<Self::Value, __E>
1350 where
1351 __E: _serde::de::Error,
1352 {
1353 match __value {
1354 0u8 => _serde::__private::Ok(__Field::__field0),
1355 1u8 => _serde::__private::Ok(__Field::__field1),
1356 2u8 => _serde::__private::Ok(__Field::__field2),
1357 _ => {
1358 _serde::__private::Err(
1359 _serde::de::Error::invalid_value(
1360 _serde::de::Unexpected::Uint8(__value),
1361 &"value(u8) of variant is one of 0, 1, 2",
1362 ),
1363 )
1364 }
1365 }
1366 }
1367 fn visit_stringptr<__E>(
1368 self,
1369 __value: StringPtr<'de>,
1370 ) -> _serde::__private::Result<Self::Value, __E>
1371 where
1372 __E: _serde::de::Error,
1373 {
1374 if let Some(__value) = __value.into_inner() {
1375 match __value.as_ref() {
1376 v if v == "0"
1377 || v.eq_ignore_ascii_case("ON_DESTRUCTION_REMAP") => {
1378 _serde::__private::Ok(__Field::__field0)
1379 }
1380 v if v == "1"
1381 || v.eq_ignore_ascii_case("ON_DESTRUCTION_REMOVE") => {
1382 _serde::__private::Ok(__Field::__field1)
1383 }
1384 v if v == "2"
1385 || v.eq_ignore_ascii_case("ON_DESTRUCTION_RESET_REMOVE") => {
1386 _serde::__private::Ok(__Field::__field2)
1387 }
1388 _ => {
1389 _serde::__private::Err(
1390 _serde::de::Error::unknown_variant(&__value, VARIANTS),
1391 )
1392 }
1393 }
1394 } else {
1395 _serde::__private::Err(
1396 _serde::de::Error::unknown_variant("None", VARIANTS),
1397 )
1398 }
1399 }
1400 }
1401 impl<'de> _serde::Deserialize<'de> for __Field {
1402 #[inline]
1403 fn deserialize<__D>(
1404 __deserializer: __D,
1405 ) -> _serde::__private::Result<Self, __D::Error>
1406 where
1407 __D: _serde::Deserializer<'de>,
1408 {
1409 _serde::Deserializer::deserialize_identifier(
1410 __deserializer,
1411 _serde::de::ReadEnumSize::Uint8,
1412 __FieldVisitor,
1413 )
1414 }
1415 }
1416 #[doc(hidden)]
1417 struct __Visitor<'de> {
1418 marker: _serde::__private::PhantomData<OnDestructionRemapInfo>,
1419 lifetime: _serde::__private::PhantomData<&'de ()>,
1420 }
1421 impl<'de> _serde::de::Visitor<'de> for __Visitor<'de> {
1422 type Value = OnDestructionRemapInfo;
1423 fn expecting(
1424 &self,
1425 __formatter: &mut _serde::__private::Formatter,
1426 ) -> _serde::__private::fmt::Result {
1427 _serde::__private::Formatter::write_str(
1428 __formatter,
1429 "enum OnDestructionRemapInfo",
1430 )
1431 }
1432 fn visit_enum<__A>(
1433 self,
1434 __data: __A,
1435 ) -> _serde::__private::Result<Self::Value, __A::Error>
1436 where
1437 __A: _serde::de::EnumAccess<'de>,
1438 {
1439 match _serde::de::EnumAccess::variant(__data)? {
1440 (__Field::__field0, __variant) => {
1441 _serde::de::VariantAccess::unit_variant(__variant)?;
1442 _serde::__private::Ok(
1443 OnDestructionRemapInfo::ON_DESTRUCTION_REMAP,
1444 )
1445 }
1446 (__Field::__field1, __variant) => {
1447 _serde::de::VariantAccess::unit_variant(__variant)?;
1448 _serde::__private::Ok(
1449 OnDestructionRemapInfo::ON_DESTRUCTION_REMOVE,
1450 )
1451 }
1452 (__Field::__field2, __variant) => {
1453 _serde::de::VariantAccess::unit_variant(__variant)?;
1454 _serde::__private::Ok(
1455 OnDestructionRemapInfo::ON_DESTRUCTION_RESET_REMOVE,
1456 )
1457 }
1458 }
1459 }
1460 }
1461 #[doc(hidden)]
1462 const VARIANTS: &'static [&'static str] = &[
1463 "ON_DESTRUCTION_REMAP",
1464 "ON_DESTRUCTION_REMOVE",
1465 "ON_DESTRUCTION_RESET_REMOVE",
1466 ];
1467 _serde::Deserializer::deserialize_enum(
1468 __deserializer,
1469 "OnDestructionRemapInfo",
1470 VARIANTS,
1471 __Visitor {
1472 marker: _serde::__private::PhantomData::<OnDestructionRemapInfo>,
1473 lifetime: _serde::__private::PhantomData,
1474 },
1475 )
1476 }
1477 }
1478};