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