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 hkbVariableBindingSetBinding<'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 = "memberPath"))]
32 #[cfg_attr(feature = "serde", serde(rename = "memberPath"))]
33 pub m_memberPath: StringPtr<'a>,
34 #[cfg_attr(feature = "json_schema", schemars(rename = "memberClass"))]
40 #[cfg_attr(feature = "serde", serde(rename = "memberClass"))]
41 pub m_memberClass: Pointer,
42 #[cfg_attr(feature = "json_schema", schemars(rename = "offsetInObjectPlusOne"))]
48 #[cfg_attr(feature = "serde", serde(rename = "offsetInObjectPlusOne"))]
49 pub m_offsetInObjectPlusOne: i32,
50 #[cfg_attr(feature = "json_schema", schemars(rename = "offsetInArrayPlusOne"))]
56 #[cfg_attr(feature = "serde", serde(rename = "offsetInArrayPlusOne"))]
57 pub m_offsetInArrayPlusOne: i32,
58 #[cfg_attr(feature = "json_schema", schemars(rename = "rootVariableIndex"))]
64 #[cfg_attr(feature = "serde", serde(rename = "rootVariableIndex"))]
65 pub m_rootVariableIndex: i32,
66 #[cfg_attr(feature = "json_schema", schemars(rename = "variableIndex"))]
71 #[cfg_attr(feature = "serde", serde(rename = "variableIndex"))]
72 pub m_variableIndex: i32,
73 #[cfg_attr(feature = "json_schema", schemars(rename = "bitIndex"))]
78 #[cfg_attr(feature = "serde", serde(rename = "bitIndex"))]
79 pub m_bitIndex: i8,
80 #[cfg_attr(feature = "json_schema", schemars(rename = "bindingType"))]
85 #[cfg_attr(feature = "serde", serde(rename = "bindingType"))]
86 pub m_bindingType: BindingType,
87 #[cfg_attr(feature = "json_schema", schemars(rename = "memberType"))]
93 #[cfg_attr(feature = "serde", serde(rename = "memberType"))]
94 pub m_memberType: u8,
95 #[cfg_attr(feature = "json_schema", schemars(rename = "variableType"))]
101 #[cfg_attr(feature = "serde", serde(rename = "variableType"))]
102 pub m_variableType: i8,
103 #[cfg_attr(feature = "json_schema", schemars(rename = "flags"))]
109 #[cfg_attr(feature = "serde", serde(rename = "flags"))]
110 pub m_flags: i8,
111}
112const _: () = {
113 use havok_serde as _serde;
114 impl<'a> _serde::HavokClass for hkbVariableBindingSetBinding<'a> {
115 #[inline]
116 fn name(&self) -> &'static str {
117 "hkbVariableBindingSetBinding"
118 }
119 #[inline]
120 fn signature(&self) -> _serde::__private::Signature {
121 _serde::__private::Signature::new(0x4d592f72)
122 }
123 #[allow(clippy::let_and_return, clippy::vec_init_then_push)]
124 fn deps_indexes(&self) -> Vec<usize> {
125 let mut v = Vec::new();
126 v.push(self.m_memberClass.get());
127 v
128 }
129 }
130 impl<'a> _serde::Serialize for hkbVariableBindingSetBinding<'a> {
131 fn serialize<S>(&self, __serializer: S) -> Result<S::Ok, S::Error>
132 where
133 S: _serde::ser::Serializer,
134 {
135 let class_meta = self
136 .__ptr
137 .map(|name| (name, _serde::__private::Signature::new(0x4d592f72)));
138 let mut serializer = __serializer
139 .serialize_struct(
140 "hkbVariableBindingSetBinding",
141 class_meta,
142 (32u64, 40u64),
143 )?;
144 serializer.serialize_field("memberPath", &self.m_memberPath)?;
145 serializer.skip_field("memberClass", &self.m_memberClass)?;
146 serializer
147 .skip_field("offsetInObjectPlusOne", &self.m_offsetInObjectPlusOne)?;
148 serializer.skip_field("offsetInArrayPlusOne", &self.m_offsetInArrayPlusOne)?;
149 serializer.skip_field("rootVariableIndex", &self.m_rootVariableIndex)?;
150 serializer.serialize_field("variableIndex", &self.m_variableIndex)?;
151 serializer.serialize_field("bitIndex", &self.m_bitIndex)?;
152 serializer.serialize_field("bindingType", &self.m_bindingType)?;
153 serializer.skip_field("memberType", &self.m_memberType)?;
154 serializer.skip_field("variableType", &self.m_variableType)?;
155 serializer.skip_field("flags", &self.m_flags)?;
156 serializer.pad_field([0u8; 3usize].as_slice(), [0u8; 3usize].as_slice())?;
157 serializer.end()
158 }
159 }
160};
161#[doc(hidden)]
162#[allow(non_upper_case_globals, unused_attributes, unused_qualifications)]
163const _: () = {
164 use havok_serde as _serde;
165 #[automatically_derived]
166 impl<'de> _serde::Deserialize<'de> for hkbVariableBindingSetBinding<'de> {
167 fn deserialize<__D>(deserializer: __D) -> core::result::Result<Self, __D::Error>
168 where
169 __D: _serde::Deserializer<'de>,
170 {
171 #[allow(non_camel_case_types)]
172 enum __Field {
173 m_memberPath,
174 m_variableIndex,
175 m_bitIndex,
176 m_bindingType,
177 __ignore,
178 }
179 struct __FieldVisitor;
180 impl<'de> _serde::de::Visitor<'de> for __FieldVisitor {
181 type Value = __Field;
182 fn expecting(
183 &self,
184 __formatter: &mut core::fmt::Formatter,
185 ) -> core::fmt::Result {
186 core::fmt::Formatter::write_str(__formatter, "field identifier")
187 }
188 #[allow(clippy::match_single_binding)]
190 #[allow(clippy::reversed_empty_ranges)]
191 #[allow(clippy::single_match)]
192 fn visit_key<__E>(
193 self,
194 __value: &str,
195 ) -> core::result::Result<Self::Value, __E>
196 where
197 __E: _serde::de::Error,
198 {
199 match __value {
200 "memberPath" => Ok(__Field::m_memberPath),
201 "variableIndex" => Ok(__Field::m_variableIndex),
202 "bitIndex" => Ok(__Field::m_bitIndex),
203 "bindingType" => Ok(__Field::m_bindingType),
204 _ => Ok(__Field::__ignore),
205 }
206 }
207 }
208 impl<'de> _serde::Deserialize<'de> for __Field {
209 #[inline]
210 fn deserialize<__D>(
211 __deserializer: __D,
212 ) -> core::result::Result<Self, __D::Error>
213 where
214 __D: _serde::Deserializer<'de>,
215 {
216 _serde::Deserializer::deserialize_key(__deserializer, __FieldVisitor)
217 }
218 }
219 struct __hkbVariableBindingSetBindingVisitor<'de> {
220 marker: _serde::__private::PhantomData<
221 hkbVariableBindingSetBinding<'de>,
222 >,
223 lifetime: _serde::__private::PhantomData<&'de ()>,
224 }
225 #[allow(clippy::match_single_binding)]
226 #[allow(clippy::reversed_empty_ranges)]
227 #[allow(clippy::single_match)]
228 impl<'de> _serde::de::Visitor<'de>
229 for __hkbVariableBindingSetBindingVisitor<'de> {
230 type Value = hkbVariableBindingSetBinding<'de>;
231 fn expecting(
232 &self,
233 __formatter: &mut core::fmt::Formatter,
234 ) -> core::fmt::Result {
235 core::fmt::Formatter::write_str(
236 __formatter,
237 "struct hkbVariableBindingSetBinding",
238 )
239 }
240 fn visit_struct_for_bytes<__A>(
241 self,
242 mut __map: __A,
243 ) -> _serde::__private::Result<Self::Value, __A::Error>
244 where
245 __A: _serde::de::MapAccess<'de>,
246 {
247 let __ptr = __A::class_ptr(&mut __map);
248 let mut m_memberPath: _serde::__private::Option<StringPtr<'de>> = _serde::__private::None;
249 let mut m_memberClass: _serde::__private::Option<Pointer> = _serde::__private::None;
250 let mut m_offsetInObjectPlusOne: _serde::__private::Option<i32> = _serde::__private::None;
251 let mut m_offsetInArrayPlusOne: _serde::__private::Option<i32> = _serde::__private::None;
252 let mut m_rootVariableIndex: _serde::__private::Option<i32> = _serde::__private::None;
253 let mut m_variableIndex: _serde::__private::Option<i32> = _serde::__private::None;
254 let mut m_bitIndex: _serde::__private::Option<i8> = _serde::__private::None;
255 let mut m_bindingType: _serde::__private::Option<BindingType> = _serde::__private::None;
256 let mut m_memberType: _serde::__private::Option<u8> = _serde::__private::None;
257 let mut m_variableType: _serde::__private::Option<i8> = _serde::__private::None;
258 let mut m_flags: _serde::__private::Option<i8> = _serde::__private::None;
259 for i in 0..11usize {
260 match i {
261 0usize => {
262 if _serde::__private::Option::is_some(&m_memberPath) {
263 return _serde::__private::Err(
264 <__A::Error as _serde::de::Error>::duplicate_field(
265 "memberPath",
266 ),
267 );
268 }
269 m_memberPath = _serde::__private::Some(
270 match __A::next_value::<StringPtr<'de>>(&mut __map) {
271 _serde::__private::Ok(__val) => __val,
272 _serde::__private::Err(__err) => {
273 return _serde::__private::Err(__err);
274 }
275 },
276 );
277 }
278 1usize => {
279 if _serde::__private::Option::is_some(&m_memberClass) {
280 return _serde::__private::Err(
281 <__A::Error as _serde::de::Error>::duplicate_field(
282 "memberClass",
283 ),
284 );
285 }
286 m_memberClass = _serde::__private::Some(
287 match __A::next_value::<Pointer>(&mut __map) {
288 _serde::__private::Ok(__val) => __val,
289 _serde::__private::Err(__err) => {
290 return _serde::__private::Err(__err);
291 }
292 },
293 );
294 }
295 2usize => {
296 if _serde::__private::Option::is_some(
297 &m_offsetInObjectPlusOne,
298 ) {
299 return _serde::__private::Err(
300 <__A::Error as _serde::de::Error>::duplicate_field(
301 "offsetInObjectPlusOne",
302 ),
303 );
304 }
305 m_offsetInObjectPlusOne = _serde::__private::Some(
306 match __A::next_value::<i32>(&mut __map) {
307 _serde::__private::Ok(__val) => __val,
308 _serde::__private::Err(__err) => {
309 return _serde::__private::Err(__err);
310 }
311 },
312 );
313 }
314 3usize => {
315 if _serde::__private::Option::is_some(
316 &m_offsetInArrayPlusOne,
317 ) {
318 return _serde::__private::Err(
319 <__A::Error as _serde::de::Error>::duplicate_field(
320 "offsetInArrayPlusOne",
321 ),
322 );
323 }
324 m_offsetInArrayPlusOne = _serde::__private::Some(
325 match __A::next_value::<i32>(&mut __map) {
326 _serde::__private::Ok(__val) => __val,
327 _serde::__private::Err(__err) => {
328 return _serde::__private::Err(__err);
329 }
330 },
331 );
332 }
333 4usize => {
334 if _serde::__private::Option::is_some(
335 &m_rootVariableIndex,
336 ) {
337 return _serde::__private::Err(
338 <__A::Error as _serde::de::Error>::duplicate_field(
339 "rootVariableIndex",
340 ),
341 );
342 }
343 m_rootVariableIndex = _serde::__private::Some(
344 match __A::next_value::<i32>(&mut __map) {
345 _serde::__private::Ok(__val) => __val,
346 _serde::__private::Err(__err) => {
347 return _serde::__private::Err(__err);
348 }
349 },
350 );
351 }
352 5usize => {
353 if _serde::__private::Option::is_some(&m_variableIndex) {
354 return _serde::__private::Err(
355 <__A::Error as _serde::de::Error>::duplicate_field(
356 "variableIndex",
357 ),
358 );
359 }
360 m_variableIndex = _serde::__private::Some(
361 match __A::next_value::<i32>(&mut __map) {
362 _serde::__private::Ok(__val) => __val,
363 _serde::__private::Err(__err) => {
364 return _serde::__private::Err(__err);
365 }
366 },
367 );
368 }
369 6usize => {
370 if _serde::__private::Option::is_some(&m_bitIndex) {
371 return _serde::__private::Err(
372 <__A::Error as _serde::de::Error>::duplicate_field(
373 "bitIndex",
374 ),
375 );
376 }
377 m_bitIndex = _serde::__private::Some(
378 match __A::next_value::<i8>(&mut __map) {
379 _serde::__private::Ok(__val) => __val,
380 _serde::__private::Err(__err) => {
381 return _serde::__private::Err(__err);
382 }
383 },
384 );
385 }
386 7usize => {
387 if _serde::__private::Option::is_some(&m_bindingType) {
388 return _serde::__private::Err(
389 <__A::Error as _serde::de::Error>::duplicate_field(
390 "bindingType",
391 ),
392 );
393 }
394 m_bindingType = _serde::__private::Some(
395 match __A::next_value::<BindingType>(&mut __map) {
396 _serde::__private::Ok(__val) => __val,
397 _serde::__private::Err(__err) => {
398 return _serde::__private::Err(__err);
399 }
400 },
401 );
402 }
403 8usize => {
404 if _serde::__private::Option::is_some(&m_memberType) {
405 return _serde::__private::Err(
406 <__A::Error as _serde::de::Error>::duplicate_field(
407 "memberType",
408 ),
409 );
410 }
411 m_memberType = _serde::__private::Some(
412 match __A::next_value::<u8>(&mut __map) {
413 _serde::__private::Ok(__val) => __val,
414 _serde::__private::Err(__err) => {
415 return _serde::__private::Err(__err);
416 }
417 },
418 );
419 }
420 9usize => {
421 if _serde::__private::Option::is_some(&m_variableType) {
422 return _serde::__private::Err(
423 <__A::Error as _serde::de::Error>::duplicate_field(
424 "variableType",
425 ),
426 );
427 }
428 m_variableType = _serde::__private::Some(
429 match __A::next_value::<i8>(&mut __map) {
430 _serde::__private::Ok(__val) => __val,
431 _serde::__private::Err(__err) => {
432 return _serde::__private::Err(__err);
433 }
434 },
435 );
436 }
437 10usize => {
438 if _serde::__private::Option::is_some(&m_flags) {
439 return _serde::__private::Err(
440 <__A::Error as _serde::de::Error>::duplicate_field("flags"),
441 );
442 }
443 m_flags = _serde::__private::Some(
444 match __A::next_value::<i8>(&mut __map) {
445 _serde::__private::Ok(__val) => __val,
446 _serde::__private::Err(__err) => {
447 return _serde::__private::Err(__err);
448 }
449 },
450 );
451 }
452 _ => {}
453 }
454 }
455 __A::pad(&mut __map, 3usize, 3usize)?;
456 let m_memberPath = match m_memberPath {
457 _serde::__private::Some(__field) => __field,
458 _serde::__private::None => {
459 return _serde::__private::Err(
460 <__A::Error as _serde::de::Error>::missing_field(
461 "memberPath",
462 ),
463 );
464 }
465 };
466 let m_memberClass = match m_memberClass {
467 _serde::__private::Some(__field) => __field,
468 _serde::__private::None => {
469 return _serde::__private::Err(
470 <__A::Error as _serde::de::Error>::missing_field(
471 "memberClass",
472 ),
473 );
474 }
475 };
476 let m_offsetInObjectPlusOne = match m_offsetInObjectPlusOne {
477 _serde::__private::Some(__field) => __field,
478 _serde::__private::None => {
479 return _serde::__private::Err(
480 <__A::Error as _serde::de::Error>::missing_field(
481 "offsetInObjectPlusOne",
482 ),
483 );
484 }
485 };
486 let m_offsetInArrayPlusOne = match m_offsetInArrayPlusOne {
487 _serde::__private::Some(__field) => __field,
488 _serde::__private::None => {
489 return _serde::__private::Err(
490 <__A::Error as _serde::de::Error>::missing_field(
491 "offsetInArrayPlusOne",
492 ),
493 );
494 }
495 };
496 let m_rootVariableIndex = match m_rootVariableIndex {
497 _serde::__private::Some(__field) => __field,
498 _serde::__private::None => {
499 return _serde::__private::Err(
500 <__A::Error as _serde::de::Error>::missing_field(
501 "rootVariableIndex",
502 ),
503 );
504 }
505 };
506 let m_variableIndex = match m_variableIndex {
507 _serde::__private::Some(__field) => __field,
508 _serde::__private::None => {
509 return _serde::__private::Err(
510 <__A::Error as _serde::de::Error>::missing_field(
511 "variableIndex",
512 ),
513 );
514 }
515 };
516 let m_bitIndex = match m_bitIndex {
517 _serde::__private::Some(__field) => __field,
518 _serde::__private::None => {
519 return _serde::__private::Err(
520 <__A::Error as _serde::de::Error>::missing_field("bitIndex"),
521 );
522 }
523 };
524 let m_bindingType = match m_bindingType {
525 _serde::__private::Some(__field) => __field,
526 _serde::__private::None => {
527 return _serde::__private::Err(
528 <__A::Error as _serde::de::Error>::missing_field(
529 "bindingType",
530 ),
531 );
532 }
533 };
534 let m_memberType = match m_memberType {
535 _serde::__private::Some(__field) => __field,
536 _serde::__private::None => {
537 return _serde::__private::Err(
538 <__A::Error as _serde::de::Error>::missing_field(
539 "memberType",
540 ),
541 );
542 }
543 };
544 let m_variableType = match m_variableType {
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 "variableType",
550 ),
551 );
552 }
553 };
554 let m_flags = match m_flags {
555 _serde::__private::Some(__field) => __field,
556 _serde::__private::None => {
557 return _serde::__private::Err(
558 <__A::Error as _serde::de::Error>::missing_field("flags"),
559 );
560 }
561 };
562 _serde::__private::Ok(hkbVariableBindingSetBinding {
563 __ptr,
564 m_memberPath,
565 m_memberClass,
566 m_offsetInObjectPlusOne,
567 m_offsetInArrayPlusOne,
568 m_rootVariableIndex,
569 m_variableIndex,
570 m_bitIndex,
571 m_bindingType,
572 m_memberType,
573 m_variableType,
574 m_flags,
575 })
576 }
577 #[allow(clippy::manual_unwrap_or_default)]
578 fn visit_struct<__A>(
579 self,
580 mut __map: __A,
581 ) -> _serde::__private::Result<Self::Value, __A::Error>
582 where
583 __A: _serde::de::MapAccess<'de>,
584 {
585 let mut m_memberPath: _serde::__private::Option<StringPtr<'de>> = _serde::__private::None;
586 let mut m_variableIndex: _serde::__private::Option<i32> = _serde::__private::None;
587 let mut m_bitIndex: _serde::__private::Option<i8> = _serde::__private::None;
588 let mut m_bindingType: _serde::__private::Option<BindingType> = _serde::__private::None;
589 while let _serde::__private::Some(__key) = {
590 __A::next_key::<__Field>(&mut __map)?
591 } {
592 match __key {
593 __Field::m_memberPath => {
594 #[cfg(
595 any(feature = "strict", feature = "ignore_duplicates")
596 )]
597 if _serde::__private::Option::is_some(&m_memberPath) {
598 #[cfg(feature = "ignore_duplicates")]
599 {
600 __A::skip_value(&mut __map)?;
601 continue;
602 }
603 #[cfg(feature = "strict")]
604 return _serde::__private::Err(
605 <__A::Error as _serde::de::Error>::duplicate_field(
606 "memberPath",
607 ),
608 );
609 }
610 m_memberPath = _serde::__private::Some(
611 match __A::next_value::<StringPtr<'de>>(&mut __map) {
612 _serde::__private::Ok(__val) => __val,
613 _serde::__private::Err(__err) => {
614 return _serde::__private::Err(__err);
615 }
616 },
617 );
618 }
619 __Field::m_variableIndex => {
620 #[cfg(
621 any(feature = "strict", feature = "ignore_duplicates")
622 )]
623 if _serde::__private::Option::is_some(&m_variableIndex) {
624 #[cfg(feature = "ignore_duplicates")]
625 {
626 __A::skip_value(&mut __map)?;
627 continue;
628 }
629 #[cfg(feature = "strict")]
630 return _serde::__private::Err(
631 <__A::Error as _serde::de::Error>::duplicate_field(
632 "variableIndex",
633 ),
634 );
635 }
636 m_variableIndex = _serde::__private::Some(
637 match __A::next_value::<i32>(&mut __map) {
638 _serde::__private::Ok(__val) => __val,
639 _serde::__private::Err(__err) => {
640 return _serde::__private::Err(__err);
641 }
642 },
643 );
644 }
645 __Field::m_bitIndex => {
646 #[cfg(
647 any(feature = "strict", feature = "ignore_duplicates")
648 )]
649 if _serde::__private::Option::is_some(&m_bitIndex) {
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(
658 "bitIndex",
659 ),
660 );
661 }
662 m_bitIndex = _serde::__private::Some(
663 match __A::next_value::<i8>(&mut __map) {
664 _serde::__private::Ok(__val) => __val,
665 _serde::__private::Err(__err) => {
666 return _serde::__private::Err(__err);
667 }
668 },
669 );
670 }
671 __Field::m_bindingType => {
672 #[cfg(
673 any(feature = "strict", feature = "ignore_duplicates")
674 )]
675 if _serde::__private::Option::is_some(&m_bindingType) {
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 "bindingType",
685 ),
686 );
687 }
688 m_bindingType = _serde::__private::Some(
689 match __A::next_value::<BindingType>(&mut __map) {
690 _serde::__private::Ok(__val) => __val,
691 _serde::__private::Err(__err) => {
692 return _serde::__private::Err(__err);
693 }
694 },
695 );
696 }
697 _ => __A::skip_value(&mut __map)?,
698 }
699 }
700 let m_memberPath = match m_memberPath {
701 _serde::__private::Some(__field) => __field,
702 _serde::__private::None => {
703 #[cfg(feature = "strict")]
704 return _serde::__private::Err(
705 <__A::Error as _serde::de::Error>::missing_field(
706 "memberPath",
707 ),
708 );
709 #[cfg(not(feature = "strict"))] Default::default()
710 }
711 };
712 let m_variableIndex = match m_variableIndex {
713 _serde::__private::Some(__field) => __field,
714 _serde::__private::None => {
715 #[cfg(feature = "strict")]
716 return _serde::__private::Err(
717 <__A::Error as _serde::de::Error>::missing_field(
718 "variableIndex",
719 ),
720 );
721 #[cfg(not(feature = "strict"))] Default::default()
722 }
723 };
724 let m_bitIndex = match m_bitIndex {
725 _serde::__private::Some(__field) => __field,
726 _serde::__private::None => {
727 #[cfg(feature = "strict")]
728 return _serde::__private::Err(
729 <__A::Error as _serde::de::Error>::missing_field("bitIndex"),
730 );
731 #[cfg(not(feature = "strict"))] Default::default()
732 }
733 };
734 let m_bindingType = match m_bindingType {
735 _serde::__private::Some(__field) => __field,
736 _serde::__private::None => {
737 #[cfg(feature = "strict")]
738 return _serde::__private::Err(
739 <__A::Error as _serde::de::Error>::missing_field(
740 "bindingType",
741 ),
742 );
743 #[cfg(not(feature = "strict"))] Default::default()
744 }
745 };
746 let __ptr = __A::class_ptr(&mut __map);
747 _serde::__private::Ok(hkbVariableBindingSetBinding {
748 __ptr,
749 m_memberPath,
750 m_variableIndex,
751 m_bitIndex,
752 m_bindingType,
753 ..Default::default()
754 })
755 }
756 }
757 const FIELDS: &[&str] = &[
758 "memberPath",
759 "memberClass",
760 "offsetInObjectPlusOne",
761 "offsetInArrayPlusOne",
762 "rootVariableIndex",
763 "variableIndex",
764 "bitIndex",
765 "bindingType",
766 "memberType",
767 "variableType",
768 "flags",
769 ];
770 _serde::Deserializer::deserialize_struct(
771 deserializer,
772 "hkbVariableBindingSetBinding",
773 FIELDS,
774 __hkbVariableBindingSetBindingVisitor {
775 marker: _serde::__private::PhantomData::<
776 hkbVariableBindingSetBinding,
777 >,
778 lifetime: _serde::__private::PhantomData,
779 },
780 )
781 }
782 }
783};
784#[allow(non_upper_case_globals, non_snake_case)]
787#[cfg_attr(feature = "json_schema", derive(schemars::JsonSchema))]
788#[cfg_attr(feature = "serde", derive(serde::Serialize, serde::Deserialize))]
789#[derive(
790 Debug,
791 Clone,
792 Default,
793 PartialEq,
794 Eq,
795 PartialOrd,
796 Ord,
797 num_derive::ToPrimitive,
798 num_derive::FromPrimitive,
799)]
800pub enum BindingType {
801 #[default]
802 BINDING_TYPE_VARIABLE = 0isize,
803 BINDING_TYPE_CHARACTER_PROPERTY = 1isize,
804}
805const _: () = {
806 use havok_serde as __serde;
807 impl __serde::Serialize for BindingType {
808 fn serialize<S>(&self, __serializer: S) -> Result<S::Ok, S::Error>
809 where
810 S: __serde::ser::Serializer,
811 {
812 let mut __serializer = __serializer.serialize_enum_flags()?;
813 match self {
814 Self::BINDING_TYPE_VARIABLE => {
815 __serializer.serialize_field("BINDING_TYPE_VARIABLE", &0u64)
816 }
817 Self::BINDING_TYPE_CHARACTER_PROPERTY => {
818 __serializer
819 .serialize_field("BINDING_TYPE_CHARACTER_PROPERTY", &1u64)
820 }
821 }?;
822 use num_traits::ToPrimitive as _;
823 let num = self
824 .to_i8()
825 .ok_or(S::Error::custom("Failed enum BindingType to_i8"))?;
826 __serializer.serialize_bits(&num)?;
827 __serializer.end()
828 }
829 }
830};
831#[doc(hidden)]
832#[allow(non_upper_case_globals, unused_attributes, unused_qualifications)]
833const _: () = {
834 #[allow(unused_extern_crates, clippy::useless_attribute)]
835 extern crate havok_serde as _serde;
836 #[automatically_derived]
837 impl<'de> _serde::Deserialize<'de> for BindingType {
838 fn deserialize<__D>(
839 __deserializer: __D,
840 ) -> _serde::__private::Result<Self, __D::Error>
841 where
842 __D: _serde::Deserializer<'de>,
843 {
844 #[allow(non_camel_case_types)]
845 #[doc(hidden)]
846 enum __Field {
847 __field0,
848 __field1,
849 }
850 #[doc(hidden)]
851 struct __FieldVisitor;
852 impl<'de> _serde::de::Visitor<'de> for __FieldVisitor {
853 type Value = __Field;
854 fn expecting(
855 &self,
856 __formatter: &mut _serde::__private::Formatter,
857 ) -> _serde::__private::fmt::Result {
858 _serde::__private::Formatter::write_str(
859 __formatter,
860 "variant identifier",
861 )
862 }
863 fn visit_int8<__E>(
864 self,
865 __value: i8,
866 ) -> _serde::__private::Result<Self::Value, __E>
867 where
868 __E: _serde::de::Error,
869 {
870 match __value {
871 0i8 => _serde::__private::Ok(__Field::__field0),
872 1i8 => _serde::__private::Ok(__Field::__field1),
873 _ => {
874 _serde::__private::Err(
875 _serde::de::Error::invalid_value(
876 _serde::de::Unexpected::Int8(__value),
877 &"value(i8) of variant is one of 0, 1",
878 ),
879 )
880 }
881 }
882 }
883 fn visit_stringptr<__E>(
884 self,
885 __value: StringPtr<'de>,
886 ) -> _serde::__private::Result<Self::Value, __E>
887 where
888 __E: _serde::de::Error,
889 {
890 if let Some(__value) = __value.into_inner() {
891 match __value.as_ref() {
892 v if v == "0"
893 || v.eq_ignore_ascii_case("BINDING_TYPE_VARIABLE") => {
894 _serde::__private::Ok(__Field::__field0)
895 }
896 v if v == "1"
897 || v
898 .eq_ignore_ascii_case("BINDING_TYPE_CHARACTER_PROPERTY") => {
899 _serde::__private::Ok(__Field::__field1)
900 }
901 _ => {
902 _serde::__private::Err(
903 _serde::de::Error::unknown_variant(&__value, VARIANTS),
904 )
905 }
906 }
907 } else {
908 _serde::__private::Err(
909 _serde::de::Error::unknown_variant("None", VARIANTS),
910 )
911 }
912 }
913 }
914 impl<'de> _serde::Deserialize<'de> for __Field {
915 #[inline]
916 fn deserialize<__D>(
917 __deserializer: __D,
918 ) -> _serde::__private::Result<Self, __D::Error>
919 where
920 __D: _serde::Deserializer<'de>,
921 {
922 _serde::Deserializer::deserialize_identifier(
923 __deserializer,
924 _serde::de::ReadEnumSize::Int8,
925 __FieldVisitor,
926 )
927 }
928 }
929 #[doc(hidden)]
930 struct __Visitor<'de> {
931 marker: _serde::__private::PhantomData<BindingType>,
932 lifetime: _serde::__private::PhantomData<&'de ()>,
933 }
934 impl<'de> _serde::de::Visitor<'de> for __Visitor<'de> {
935 type Value = BindingType;
936 fn expecting(
937 &self,
938 __formatter: &mut _serde::__private::Formatter,
939 ) -> _serde::__private::fmt::Result {
940 _serde::__private::Formatter::write_str(
941 __formatter,
942 "enum BindingType",
943 )
944 }
945 fn visit_enum<__A>(
946 self,
947 __data: __A,
948 ) -> _serde::__private::Result<Self::Value, __A::Error>
949 where
950 __A: _serde::de::EnumAccess<'de>,
951 {
952 match _serde::de::EnumAccess::variant(__data)? {
953 (__Field::__field0, __variant) => {
954 _serde::de::VariantAccess::unit_variant(__variant)?;
955 _serde::__private::Ok(BindingType::BINDING_TYPE_VARIABLE)
956 }
957 (__Field::__field1, __variant) => {
958 _serde::de::VariantAccess::unit_variant(__variant)?;
959 _serde::__private::Ok(
960 BindingType::BINDING_TYPE_CHARACTER_PROPERTY,
961 )
962 }
963 }
964 }
965 }
966 #[doc(hidden)]
967 const VARIANTS: &'static [&'static str] = &[
968 "BINDING_TYPE_VARIABLE",
969 "BINDING_TYPE_CHARACTER_PROPERTY",
970 ];
971 _serde::Deserializer::deserialize_enum(
972 __deserializer,
973 "BindingType",
974 VARIANTS,
975 __Visitor {
976 marker: _serde::__private::PhantomData::<BindingType>,
977 lifetime: _serde::__private::PhantomData,
978 },
979 )
980 }
981 }
982};