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