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 hkpTriggerVolume {
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 = "overlappingBodies"))]
35 #[cfg_attr(feature = "serde", serde(rename = "overlappingBodies"))]
36 pub m_overlappingBodies: Vec<Pointer>,
37 #[cfg_attr(feature = "json_schema", schemars(rename = "eventQueue"))]
42 #[cfg_attr(feature = "serde", serde(rename = "eventQueue"))]
43 pub m_eventQueue: Vec<hkpTriggerVolumeEventInfo>,
44 #[cfg_attr(feature = "json_schema", schemars(rename = "triggerBody"))]
49 #[cfg_attr(feature = "serde", serde(rename = "triggerBody"))]
50 pub m_triggerBody: Pointer,
51 #[cfg_attr(feature = "json_schema", schemars(rename = "sequenceNumber"))]
56 #[cfg_attr(feature = "serde", serde(rename = "sequenceNumber"))]
57 pub m_sequenceNumber: u32,
58}
59const _: () = {
60 use havok_serde as _serde;
61 impl _serde::HavokClass for hkpTriggerVolume {
62 #[inline]
63 fn name(&self) -> &'static str {
64 "hkpTriggerVolume"
65 }
66 #[inline]
67 fn signature(&self) -> _serde::__private::Signature {
68 _serde::__private::Signature::new(0xa29a8d1a)
69 }
70 #[allow(clippy::let_and_return, clippy::vec_init_then_push)]
71 fn deps_indexes(&self) -> Vec<usize> {
72 let mut v = Vec::new();
73 v.extend(self.m_overlappingBodies.iter().map(|ptr| ptr.get()));
74 v.extend(
75 self
76 .m_eventQueue
77 .iter()
78 .flat_map(|class| class.deps_indexes())
79 .collect::<Vec<usize>>(),
80 );
81 v.push(self.m_triggerBody.get());
82 v
83 }
84 }
85 impl _serde::Serialize for hkpTriggerVolume {
86 fn serialize<S>(&self, __serializer: S) -> Result<S::Ok, S::Error>
87 where
88 S: _serde::ser::Serializer,
89 {
90 let class_meta = self
91 .__ptr
92 .map(|name| (name, _serde::__private::Signature::new(0xa29a8d1a)));
93 let mut serializer = __serializer
94 .serialize_struct("hkpTriggerVolume", class_meta, (52u64, 88u64))?;
95 serializer.pad_field([0u8; 4usize].as_slice(), [0u8; 8usize].as_slice())?;
96 serializer.skip_field("memSizeAndFlags", &self.parent.m_memSizeAndFlags)?;
97 serializer.skip_field("referenceCount", &self.parent.m_referenceCount)?;
98 serializer.pad_field([0u8; 0usize].as_slice(), [0u8; 4usize].as_slice())?;
99 serializer.pad_field([0u8; 12usize].as_slice(), [0u8; 24usize].as_slice())?;
100 serializer
101 .serialize_array_field(
102 "overlappingBodies",
103 &self.m_overlappingBodies,
104 TypeSize::NonPtr,
105 )?;
106 serializer
107 .serialize_array_field(
108 "eventQueue",
109 &self.m_eventQueue,
110 TypeSize::Struct {
111 size_x86: 16u64,
112 size_x86_64: 24u64,
113 },
114 )?;
115 serializer.serialize_field("triggerBody", &self.m_triggerBody)?;
116 serializer.serialize_field("sequenceNumber", &self.m_sequenceNumber)?;
117 serializer.pad_field([0u8; 0usize].as_slice(), [0u8; 4usize].as_slice())?;
118 serializer.end()
119 }
120 }
121};
122#[doc(hidden)]
123#[allow(non_upper_case_globals, unused_attributes, unused_qualifications)]
124const _: () = {
125 use havok_serde as _serde;
126 #[automatically_derived]
127 impl<'de> _serde::Deserialize<'de> for hkpTriggerVolume {
128 fn deserialize<__D>(deserializer: __D) -> core::result::Result<Self, __D::Error>
129 where
130 __D: _serde::Deserializer<'de>,
131 {
132 #[allow(non_camel_case_types)]
133 enum __Field {
134 m_overlappingBodies,
135 m_eventQueue,
136 m_triggerBody,
137 m_sequenceNumber,
138 __ignore,
139 }
140 struct __FieldVisitor;
141 impl<'de> _serde::de::Visitor<'de> for __FieldVisitor {
142 type Value = __Field;
143 fn expecting(
144 &self,
145 __formatter: &mut core::fmt::Formatter,
146 ) -> core::fmt::Result {
147 core::fmt::Formatter::write_str(__formatter, "field identifier")
148 }
149 #[allow(clippy::match_single_binding)]
151 #[allow(clippy::reversed_empty_ranges)]
152 #[allow(clippy::single_match)]
153 fn visit_key<__E>(
154 self,
155 __value: &str,
156 ) -> core::result::Result<Self::Value, __E>
157 where
158 __E: _serde::de::Error,
159 {
160 match __value {
161 "overlappingBodies" => Ok(__Field::m_overlappingBodies),
162 "eventQueue" => Ok(__Field::m_eventQueue),
163 "triggerBody" => Ok(__Field::m_triggerBody),
164 "sequenceNumber" => Ok(__Field::m_sequenceNumber),
165 _ => Ok(__Field::__ignore),
166 }
167 }
168 }
169 impl<'de> _serde::Deserialize<'de> for __Field {
170 #[inline]
171 fn deserialize<__D>(
172 __deserializer: __D,
173 ) -> core::result::Result<Self, __D::Error>
174 where
175 __D: _serde::Deserializer<'de>,
176 {
177 _serde::Deserializer::deserialize_key(__deserializer, __FieldVisitor)
178 }
179 }
180 struct __hkpTriggerVolumeVisitor<'de> {
181 marker: _serde::__private::PhantomData<hkpTriggerVolume>,
182 lifetime: _serde::__private::PhantomData<&'de ()>,
183 }
184 #[allow(clippy::match_single_binding)]
185 #[allow(clippy::reversed_empty_ranges)]
186 #[allow(clippy::single_match)]
187 impl<'de> _serde::de::Visitor<'de> for __hkpTriggerVolumeVisitor<'de> {
188 type Value = hkpTriggerVolume;
189 fn expecting(
190 &self,
191 __formatter: &mut core::fmt::Formatter,
192 ) -> core::fmt::Result {
193 core::fmt::Formatter::write_str(
194 __formatter,
195 "struct hkpTriggerVolume",
196 )
197 }
198 fn visit_struct_for_bytes<__A>(
199 self,
200 mut __map: __A,
201 ) -> _serde::__private::Result<Self::Value, __A::Error>
202 where
203 __A: _serde::de::MapAccess<'de>,
204 {
205 let __ptr = __A::class_ptr(&mut __map);
206 let parent = __A::parent_value(&mut __map)?;
207 let mut m_overlappingBodies: _serde::__private::Option<
208 Vec<Pointer>,
209 > = _serde::__private::None;
210 let mut m_eventQueue: _serde::__private::Option<
211 Vec<hkpTriggerVolumeEventInfo>,
212 > = _serde::__private::None;
213 let mut m_triggerBody: _serde::__private::Option<Pointer> = _serde::__private::None;
214 let mut m_sequenceNumber: _serde::__private::Option<u32> = _serde::__private::None;
215 for i in 0..4usize {
216 match i {
217 0usize => {
218 if _serde::__private::Option::is_some(
219 &m_overlappingBodies,
220 ) {
221 return _serde::__private::Err(
222 <__A::Error as _serde::de::Error>::duplicate_field(
223 "overlappingBodies",
224 ),
225 );
226 }
227 __A::pad(&mut __map, 12usize, 24usize)?;
228 m_overlappingBodies = _serde::__private::Some(
229 match __A::next_value::<Vec<Pointer>>(&mut __map) {
230 _serde::__private::Ok(__val) => __val,
231 _serde::__private::Err(__err) => {
232 return _serde::__private::Err(__err);
233 }
234 },
235 );
236 }
237 1usize => {
238 if _serde::__private::Option::is_some(&m_eventQueue) {
239 return _serde::__private::Err(
240 <__A::Error as _serde::de::Error>::duplicate_field(
241 "eventQueue",
242 ),
243 );
244 }
245 m_eventQueue = _serde::__private::Some(
246 match __A::next_value::<
247 Vec<hkpTriggerVolumeEventInfo>,
248 >(&mut __map) {
249 _serde::__private::Ok(__val) => __val,
250 _serde::__private::Err(__err) => {
251 return _serde::__private::Err(__err);
252 }
253 },
254 );
255 }
256 2usize => {
257 if _serde::__private::Option::is_some(&m_triggerBody) {
258 return _serde::__private::Err(
259 <__A::Error as _serde::de::Error>::duplicate_field(
260 "triggerBody",
261 ),
262 );
263 }
264 m_triggerBody = _serde::__private::Some(
265 match __A::next_value::<Pointer>(&mut __map) {
266 _serde::__private::Ok(__val) => __val,
267 _serde::__private::Err(__err) => {
268 return _serde::__private::Err(__err);
269 }
270 },
271 );
272 }
273 3usize => {
274 if _serde::__private::Option::is_some(&m_sequenceNumber) {
275 return _serde::__private::Err(
276 <__A::Error as _serde::de::Error>::duplicate_field(
277 "sequenceNumber",
278 ),
279 );
280 }
281 m_sequenceNumber = _serde::__private::Some(
282 match __A::next_value::<u32>(&mut __map) {
283 _serde::__private::Ok(__val) => __val,
284 _serde::__private::Err(__err) => {
285 return _serde::__private::Err(__err);
286 }
287 },
288 );
289 }
290 _ => {}
291 }
292 }
293 __A::pad(&mut __map, 0usize, 4usize)?;
294 let m_overlappingBodies = match m_overlappingBodies {
295 _serde::__private::Some(__field) => __field,
296 _serde::__private::None => {
297 return _serde::__private::Err(
298 <__A::Error as _serde::de::Error>::missing_field(
299 "overlappingBodies",
300 ),
301 );
302 }
303 };
304 let m_eventQueue = match m_eventQueue {
305 _serde::__private::Some(__field) => __field,
306 _serde::__private::None => {
307 return _serde::__private::Err(
308 <__A::Error as _serde::de::Error>::missing_field(
309 "eventQueue",
310 ),
311 );
312 }
313 };
314 let m_triggerBody = match m_triggerBody {
315 _serde::__private::Some(__field) => __field,
316 _serde::__private::None => {
317 return _serde::__private::Err(
318 <__A::Error as _serde::de::Error>::missing_field(
319 "triggerBody",
320 ),
321 );
322 }
323 };
324 let m_sequenceNumber = match m_sequenceNumber {
325 _serde::__private::Some(__field) => __field,
326 _serde::__private::None => {
327 return _serde::__private::Err(
328 <__A::Error as _serde::de::Error>::missing_field(
329 "sequenceNumber",
330 ),
331 );
332 }
333 };
334 _serde::__private::Ok(hkpTriggerVolume {
335 __ptr,
336 parent,
337 m_overlappingBodies,
338 m_eventQueue,
339 m_triggerBody,
340 m_sequenceNumber,
341 })
342 }
343 #[allow(clippy::manual_unwrap_or_default)]
344 fn visit_struct<__A>(
345 self,
346 mut __map: __A,
347 ) -> _serde::__private::Result<Self::Value, __A::Error>
348 where
349 __A: _serde::de::MapAccess<'de>,
350 {
351 let mut m_overlappingBodies: _serde::__private::Option<
352 Vec<Pointer>,
353 > = _serde::__private::None;
354 let mut m_eventQueue: _serde::__private::Option<
355 Vec<hkpTriggerVolumeEventInfo>,
356 > = _serde::__private::None;
357 let mut m_triggerBody: _serde::__private::Option<Pointer> = _serde::__private::None;
358 let mut m_sequenceNumber: _serde::__private::Option<u32> = _serde::__private::None;
359 while let _serde::__private::Some(__key) = {
360 __A::next_key::<__Field>(&mut __map)?
361 } {
362 match __key {
363 __Field::m_overlappingBodies => {
364 #[cfg(
365 any(feature = "strict", feature = "ignore_duplicates")
366 )]
367 if _serde::__private::Option::is_some(
368 &m_overlappingBodies,
369 ) {
370 #[cfg(feature = "ignore_duplicates")]
371 {
372 __A::skip_value(&mut __map)?;
373 continue;
374 }
375 #[cfg(feature = "strict")]
376 return _serde::__private::Err(
377 <__A::Error as _serde::de::Error>::duplicate_field(
378 "overlappingBodies",
379 ),
380 );
381 }
382 m_overlappingBodies = _serde::__private::Some(
383 match __A::next_value::<Vec<Pointer>>(&mut __map) {
384 _serde::__private::Ok(__val) => __val,
385 _serde::__private::Err(__err) => {
386 return _serde::__private::Err(__err);
387 }
388 },
389 );
390 }
391 __Field::m_eventQueue => {
392 #[cfg(
393 any(feature = "strict", feature = "ignore_duplicates")
394 )]
395 if _serde::__private::Option::is_some(&m_eventQueue) {
396 #[cfg(feature = "ignore_duplicates")]
397 {
398 __A::skip_value(&mut __map)?;
399 continue;
400 }
401 #[cfg(feature = "strict")]
402 return _serde::__private::Err(
403 <__A::Error as _serde::de::Error>::duplicate_field(
404 "eventQueue",
405 ),
406 );
407 }
408 m_eventQueue = _serde::__private::Some(
409 match __A::next_value::<
410 Vec<hkpTriggerVolumeEventInfo>,
411 >(&mut __map) {
412 _serde::__private::Ok(__val) => __val,
413 _serde::__private::Err(__err) => {
414 return _serde::__private::Err(__err);
415 }
416 },
417 );
418 }
419 __Field::m_triggerBody => {
420 #[cfg(
421 any(feature = "strict", feature = "ignore_duplicates")
422 )]
423 if _serde::__private::Option::is_some(&m_triggerBody) {
424 #[cfg(feature = "ignore_duplicates")]
425 {
426 __A::skip_value(&mut __map)?;
427 continue;
428 }
429 #[cfg(feature = "strict")]
430 return _serde::__private::Err(
431 <__A::Error as _serde::de::Error>::duplicate_field(
432 "triggerBody",
433 ),
434 );
435 }
436 m_triggerBody = _serde::__private::Some(
437 match __A::next_value::<Pointer>(&mut __map) {
438 _serde::__private::Ok(__val) => __val,
439 _serde::__private::Err(__err) => {
440 return _serde::__private::Err(__err);
441 }
442 },
443 );
444 }
445 __Field::m_sequenceNumber => {
446 #[cfg(
447 any(feature = "strict", feature = "ignore_duplicates")
448 )]
449 if _serde::__private::Option::is_some(&m_sequenceNumber) {
450 #[cfg(feature = "ignore_duplicates")]
451 {
452 __A::skip_value(&mut __map)?;
453 continue;
454 }
455 #[cfg(feature = "strict")]
456 return _serde::__private::Err(
457 <__A::Error as _serde::de::Error>::duplicate_field(
458 "sequenceNumber",
459 ),
460 );
461 }
462 m_sequenceNumber = _serde::__private::Some(
463 match __A::next_value::<u32>(&mut __map) {
464 _serde::__private::Ok(__val) => __val,
465 _serde::__private::Err(__err) => {
466 return _serde::__private::Err(__err);
467 }
468 },
469 );
470 }
471 _ => __A::skip_value(&mut __map)?,
472 }
473 }
474 let m_overlappingBodies = match m_overlappingBodies {
475 _serde::__private::Some(__field) => __field,
476 _serde::__private::None => {
477 #[cfg(feature = "strict")]
478 return _serde::__private::Err(
479 <__A::Error as _serde::de::Error>::missing_field(
480 "overlappingBodies",
481 ),
482 );
483 #[cfg(not(feature = "strict"))] Default::default()
484 }
485 };
486 let m_eventQueue = match m_eventQueue {
487 _serde::__private::Some(__field) => __field,
488 _serde::__private::None => {
489 #[cfg(feature = "strict")]
490 return _serde::__private::Err(
491 <__A::Error as _serde::de::Error>::missing_field(
492 "eventQueue",
493 ),
494 );
495 #[cfg(not(feature = "strict"))] Default::default()
496 }
497 };
498 let m_triggerBody = match m_triggerBody {
499 _serde::__private::Some(__field) => __field,
500 _serde::__private::None => {
501 #[cfg(feature = "strict")]
502 return _serde::__private::Err(
503 <__A::Error as _serde::de::Error>::missing_field(
504 "triggerBody",
505 ),
506 );
507 #[cfg(not(feature = "strict"))] Default::default()
508 }
509 };
510 let m_sequenceNumber = match m_sequenceNumber {
511 _serde::__private::Some(__field) => __field,
512 _serde::__private::None => {
513 #[cfg(feature = "strict")]
514 return _serde::__private::Err(
515 <__A::Error as _serde::de::Error>::missing_field(
516 "sequenceNumber",
517 ),
518 );
519 #[cfg(not(feature = "strict"))] Default::default()
520 }
521 };
522 let __ptr = None;
523 let parent = hkBaseObject { __ptr };
524 let parent = hkReferencedObject {
525 __ptr,
526 parent,
527 ..Default::default()
528 };
529 let __ptr = __A::class_ptr(&mut __map);
530 _serde::__private::Ok(hkpTriggerVolume {
531 __ptr,
532 parent,
533 m_overlappingBodies,
534 m_eventQueue,
535 m_triggerBody,
536 m_sequenceNumber,
537 })
538 }
539 }
540 const FIELDS: &[&str] = &[
541 "overlappingBodies",
542 "eventQueue",
543 "triggerBody",
544 "sequenceNumber",
545 ];
546 _serde::Deserializer::deserialize_struct(
547 deserializer,
548 "hkpTriggerVolume",
549 FIELDS,
550 __hkpTriggerVolumeVisitor {
551 marker: _serde::__private::PhantomData::<hkpTriggerVolume>,
552 lifetime: _serde::__private::PhantomData,
553 },
554 )
555 }
556 }
557};
558#[allow(non_upper_case_globals, non_snake_case)]
561#[cfg_attr(feature = "json_schema", derive(schemars::JsonSchema))]
562#[cfg_attr(feature = "serde", derive(serde::Serialize, serde::Deserialize))]
563#[derive(
564 Debug,
565 Clone,
566 Default,
567 PartialEq,
568 Eq,
569 PartialOrd,
570 Ord,
571 num_derive::ToPrimitive,
572 num_derive::FromPrimitive,
573)]
574pub enum Operation {
575 #[default]
576 ADDED_OP = 0isize,
577 REMOVED_OP = 1isize,
578 CONTACT_OP = 2isize,
579 TOI_OP = 3isize,
580}
581const _: () = {
582 use havok_serde as __serde;
583 impl __serde::Serialize for Operation {
584 fn serialize<S>(&self, __serializer: S) -> Result<S::Ok, S::Error>
585 where
586 S: __serde::ser::Serializer,
587 {
588 let mut __serializer = __serializer.serialize_enum_flags()?;
589 match self {
590 Self::ADDED_OP => __serializer.serialize_field("ADDED_OP", &0u64),
591 Self::REMOVED_OP => __serializer.serialize_field("REMOVED_OP", &1u64),
592 Self::CONTACT_OP => __serializer.serialize_field("CONTACT_OP", &2u64),
593 Self::TOI_OP => __serializer.serialize_field("TOI_OP", &3u64),
594 }?;
595 use num_traits::ToPrimitive as _;
596 let num = self
597 .to_i32()
598 .ok_or(S::Error::custom("Failed enum Operation to_i32"))?;
599 __serializer.serialize_bits(&num)?;
600 __serializer.end()
601 }
602 }
603};
604#[doc(hidden)]
605#[allow(non_upper_case_globals, unused_attributes, unused_qualifications)]
606const _: () = {
607 #[allow(unused_extern_crates, clippy::useless_attribute)]
608 extern crate havok_serde as _serde;
609 #[automatically_derived]
610 impl<'de> _serde::Deserialize<'de> for Operation {
611 fn deserialize<__D>(
612 __deserializer: __D,
613 ) -> _serde::__private::Result<Self, __D::Error>
614 where
615 __D: _serde::Deserializer<'de>,
616 {
617 #[allow(non_camel_case_types)]
618 #[doc(hidden)]
619 enum __Field {
620 __field0,
621 __field1,
622 __field2,
623 __field3,
624 }
625 #[doc(hidden)]
626 struct __FieldVisitor;
627 impl<'de> _serde::de::Visitor<'de> for __FieldVisitor {
628 type Value = __Field;
629 fn expecting(
630 &self,
631 __formatter: &mut _serde::__private::Formatter,
632 ) -> _serde::__private::fmt::Result {
633 _serde::__private::Formatter::write_str(
634 __formatter,
635 "variant identifier",
636 )
637 }
638 fn visit_int32<__E>(
639 self,
640 __value: i32,
641 ) -> _serde::__private::Result<Self::Value, __E>
642 where
643 __E: _serde::de::Error,
644 {
645 match __value {
646 0i32 => _serde::__private::Ok(__Field::__field0),
647 1i32 => _serde::__private::Ok(__Field::__field1),
648 2i32 => _serde::__private::Ok(__Field::__field2),
649 3i32 => _serde::__private::Ok(__Field::__field3),
650 _ => {
651 _serde::__private::Err(
652 _serde::de::Error::invalid_value(
653 _serde::de::Unexpected::Int32(__value),
654 &"value(i32) of variant is one of 0, 1, 2, 3",
655 ),
656 )
657 }
658 }
659 }
660 fn visit_stringptr<__E>(
661 self,
662 __value: StringPtr<'de>,
663 ) -> _serde::__private::Result<Self::Value, __E>
664 where
665 __E: _serde::de::Error,
666 {
667 if let Some(__value) = __value.into_inner() {
668 match __value.as_ref() {
669 v if v == "0" || v.eq_ignore_ascii_case("ADDED_OP") => {
670 _serde::__private::Ok(__Field::__field0)
671 }
672 v if v == "1" || v.eq_ignore_ascii_case("REMOVED_OP") => {
673 _serde::__private::Ok(__Field::__field1)
674 }
675 v if v == "2" || v.eq_ignore_ascii_case("CONTACT_OP") => {
676 _serde::__private::Ok(__Field::__field2)
677 }
678 v if v == "3" || v.eq_ignore_ascii_case("TOI_OP") => {
679 _serde::__private::Ok(__Field::__field3)
680 }
681 _ => {
682 _serde::__private::Err(
683 _serde::de::Error::unknown_variant(&__value, VARIANTS),
684 )
685 }
686 }
687 } else {
688 _serde::__private::Err(
689 _serde::de::Error::unknown_variant("None", VARIANTS),
690 )
691 }
692 }
693 }
694 impl<'de> _serde::Deserialize<'de> for __Field {
695 #[inline]
696 fn deserialize<__D>(
697 __deserializer: __D,
698 ) -> _serde::__private::Result<Self, __D::Error>
699 where
700 __D: _serde::Deserializer<'de>,
701 {
702 _serde::Deserializer::deserialize_identifier(
703 __deserializer,
704 _serde::de::ReadEnumSize::Int32,
705 __FieldVisitor,
706 )
707 }
708 }
709 #[doc(hidden)]
710 struct __Visitor<'de> {
711 marker: _serde::__private::PhantomData<Operation>,
712 lifetime: _serde::__private::PhantomData<&'de ()>,
713 }
714 impl<'de> _serde::de::Visitor<'de> for __Visitor<'de> {
715 type Value = Operation;
716 fn expecting(
717 &self,
718 __formatter: &mut _serde::__private::Formatter,
719 ) -> _serde::__private::fmt::Result {
720 _serde::__private::Formatter::write_str(
721 __formatter,
722 "enum Operation",
723 )
724 }
725 fn visit_enum<__A>(
726 self,
727 __data: __A,
728 ) -> _serde::__private::Result<Self::Value, __A::Error>
729 where
730 __A: _serde::de::EnumAccess<'de>,
731 {
732 match _serde::de::EnumAccess::variant(__data)? {
733 (__Field::__field0, __variant) => {
734 _serde::de::VariantAccess::unit_variant(__variant)?;
735 _serde::__private::Ok(Operation::ADDED_OP)
736 }
737 (__Field::__field1, __variant) => {
738 _serde::de::VariantAccess::unit_variant(__variant)?;
739 _serde::__private::Ok(Operation::REMOVED_OP)
740 }
741 (__Field::__field2, __variant) => {
742 _serde::de::VariantAccess::unit_variant(__variant)?;
743 _serde::__private::Ok(Operation::CONTACT_OP)
744 }
745 (__Field::__field3, __variant) => {
746 _serde::de::VariantAccess::unit_variant(__variant)?;
747 _serde::__private::Ok(Operation::TOI_OP)
748 }
749 }
750 }
751 }
752 #[doc(hidden)]
753 const VARIANTS: &'static [&'static str] = &[
754 "ADDED_OP",
755 "REMOVED_OP",
756 "CONTACT_OP",
757 "TOI_OP",
758 ];
759 _serde::Deserializer::deserialize_enum(
760 __deserializer,
761 "Operation",
762 VARIANTS,
763 __Visitor {
764 marker: _serde::__private::PhantomData::<Operation>,
765 lifetime: _serde::__private::PhantomData,
766 },
767 )
768 }
769 }
770};