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 hkbStateMachineProspectiveTransitionInfo {
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 = "transitionInfoReference"))]
31 #[cfg_attr(feature = "serde", serde(rename = "transitionInfoReference"))]
32 pub m_transitionInfoReference: hkbStateMachineTransitionInfoReference,
33 #[cfg_attr(
38 feature = "json_schema",
39 schemars(rename = "transitionInfoReferenceForTE")
40 )]
41 #[cfg_attr(feature = "serde", serde(rename = "transitionInfoReferenceForTE"))]
42 pub m_transitionInfoReferenceForTE: hkbStateMachineTransitionInfoReference,
43 #[cfg_attr(feature = "json_schema", schemars(rename = "toStateId"))]
48 #[cfg_attr(feature = "serde", serde(rename = "toStateId"))]
49 pub m_toStateId: i32,
50}
51const _: () = {
52 use havok_serde as _serde;
53 impl _serde::HavokClass for hkbStateMachineProspectiveTransitionInfo {
54 #[inline]
55 fn name(&self) -> &'static str {
56 "hkbStateMachineProspectiveTransitionInfo"
57 }
58 #[inline]
59 fn signature(&self) -> _serde::__private::Signature {
60 _serde::__private::Signature::new(0x3ab09a2e)
61 }
62 #[allow(clippy::let_and_return, clippy::vec_init_then_push)]
63 fn deps_indexes(&self) -> Vec<usize> {
64 let mut v = Vec::new();
65 v.extend(self.m_transitionInfoReference.deps_indexes());
66 v.extend(self.m_transitionInfoReferenceForTE.deps_indexes());
67 v
68 }
69 }
70 impl _serde::Serialize for hkbStateMachineProspectiveTransitionInfo {
71 fn serialize<S>(&self, __serializer: S) -> Result<S::Ok, S::Error>
72 where
73 S: _serde::ser::Serializer,
74 {
75 let class_meta = self
76 .__ptr
77 .map(|name| (name, _serde::__private::Signature::new(0x3ab09a2e)));
78 let mut serializer = __serializer
79 .serialize_struct(
80 "hkbStateMachineProspectiveTransitionInfo",
81 class_meta,
82 (16u64, 16u64),
83 )?;
84 serializer
85 .serialize_field(
86 "transitionInfoReference",
87 &self.m_transitionInfoReference,
88 )?;
89 serializer
90 .serialize_field(
91 "transitionInfoReferenceForTE",
92 &self.m_transitionInfoReferenceForTE,
93 )?;
94 serializer.serialize_field("toStateId", &self.m_toStateId)?;
95 serializer.end()
96 }
97 }
98};
99#[doc(hidden)]
100#[allow(non_upper_case_globals, unused_attributes, unused_qualifications)]
101const _: () = {
102 use havok_serde as _serde;
103 #[automatically_derived]
104 impl<'de> _serde::Deserialize<'de> for hkbStateMachineProspectiveTransitionInfo {
105 fn deserialize<__D>(deserializer: __D) -> core::result::Result<Self, __D::Error>
106 where
107 __D: _serde::Deserializer<'de>,
108 {
109 #[allow(non_camel_case_types)]
110 enum __Field {
111 m_transitionInfoReference,
112 m_transitionInfoReferenceForTE,
113 m_toStateId,
114 __ignore,
115 }
116 struct __FieldVisitor;
117 impl<'de> _serde::de::Visitor<'de> for __FieldVisitor {
118 type Value = __Field;
119 fn expecting(
120 &self,
121 __formatter: &mut core::fmt::Formatter,
122 ) -> core::fmt::Result {
123 core::fmt::Formatter::write_str(__formatter, "field identifier")
124 }
125 #[allow(clippy::match_single_binding)]
127 #[allow(clippy::reversed_empty_ranges)]
128 #[allow(clippy::single_match)]
129 fn visit_key<__E>(
130 self,
131 __value: &str,
132 ) -> core::result::Result<Self::Value, __E>
133 where
134 __E: _serde::de::Error,
135 {
136 match __value {
137 "transitionInfoReference" => {
138 Ok(__Field::m_transitionInfoReference)
139 }
140 "transitionInfoReferenceForTE" => {
141 Ok(__Field::m_transitionInfoReferenceForTE)
142 }
143 "toStateId" => Ok(__Field::m_toStateId),
144 _ => Ok(__Field::__ignore),
145 }
146 }
147 }
148 impl<'de> _serde::Deserialize<'de> for __Field {
149 #[inline]
150 fn deserialize<__D>(
151 __deserializer: __D,
152 ) -> core::result::Result<Self, __D::Error>
153 where
154 __D: _serde::Deserializer<'de>,
155 {
156 _serde::Deserializer::deserialize_key(__deserializer, __FieldVisitor)
157 }
158 }
159 struct __hkbStateMachineProspectiveTransitionInfoVisitor<'de> {
160 marker: _serde::__private::PhantomData<
161 hkbStateMachineProspectiveTransitionInfo,
162 >,
163 lifetime: _serde::__private::PhantomData<&'de ()>,
164 }
165 #[allow(clippy::match_single_binding)]
166 #[allow(clippy::reversed_empty_ranges)]
167 #[allow(clippy::single_match)]
168 impl<'de> _serde::de::Visitor<'de>
169 for __hkbStateMachineProspectiveTransitionInfoVisitor<'de> {
170 type Value = hkbStateMachineProspectiveTransitionInfo;
171 fn expecting(
172 &self,
173 __formatter: &mut core::fmt::Formatter,
174 ) -> core::fmt::Result {
175 core::fmt::Formatter::write_str(
176 __formatter,
177 "struct hkbStateMachineProspectiveTransitionInfo",
178 )
179 }
180 fn visit_struct_for_bytes<__A>(
181 self,
182 mut __map: __A,
183 ) -> _serde::__private::Result<Self::Value, __A::Error>
184 where
185 __A: _serde::de::MapAccess<'de>,
186 {
187 let __ptr = __A::class_ptr(&mut __map);
188 let mut m_transitionInfoReference: _serde::__private::Option<
189 hkbStateMachineTransitionInfoReference,
190 > = _serde::__private::None;
191 let mut m_transitionInfoReferenceForTE: _serde::__private::Option<
192 hkbStateMachineTransitionInfoReference,
193 > = _serde::__private::None;
194 let mut m_toStateId: _serde::__private::Option<i32> = _serde::__private::None;
195 for i in 0..3usize {
196 match i {
197 0usize => {
198 if _serde::__private::Option::is_some(
199 &m_transitionInfoReference,
200 ) {
201 return _serde::__private::Err(
202 <__A::Error as _serde::de::Error>::duplicate_field(
203 "transitionInfoReference",
204 ),
205 );
206 }
207 m_transitionInfoReference = _serde::__private::Some(
208 match __A::next_value::<
209 hkbStateMachineTransitionInfoReference,
210 >(&mut __map) {
211 _serde::__private::Ok(__val) => __val,
212 _serde::__private::Err(__err) => {
213 return _serde::__private::Err(__err);
214 }
215 },
216 );
217 }
218 1usize => {
219 if _serde::__private::Option::is_some(
220 &m_transitionInfoReferenceForTE,
221 ) {
222 return _serde::__private::Err(
223 <__A::Error as _serde::de::Error>::duplicate_field(
224 "transitionInfoReferenceForTE",
225 ),
226 );
227 }
228 m_transitionInfoReferenceForTE = _serde::__private::Some(
229 match __A::next_value::<
230 hkbStateMachineTransitionInfoReference,
231 >(&mut __map) {
232 _serde::__private::Ok(__val) => __val,
233 _serde::__private::Err(__err) => {
234 return _serde::__private::Err(__err);
235 }
236 },
237 );
238 }
239 2usize => {
240 if _serde::__private::Option::is_some(&m_toStateId) {
241 return _serde::__private::Err(
242 <__A::Error as _serde::de::Error>::duplicate_field(
243 "toStateId",
244 ),
245 );
246 }
247 m_toStateId = _serde::__private::Some(
248 match __A::next_value::<i32>(&mut __map) {
249 _serde::__private::Ok(__val) => __val,
250 _serde::__private::Err(__err) => {
251 return _serde::__private::Err(__err);
252 }
253 },
254 );
255 }
256 _ => {}
257 }
258 }
259 let m_transitionInfoReference = match m_transitionInfoReference {
260 _serde::__private::Some(__field) => __field,
261 _serde::__private::None => {
262 return _serde::__private::Err(
263 <__A::Error as _serde::de::Error>::missing_field(
264 "transitionInfoReference",
265 ),
266 );
267 }
268 };
269 let m_transitionInfoReferenceForTE = match m_transitionInfoReferenceForTE {
270 _serde::__private::Some(__field) => __field,
271 _serde::__private::None => {
272 return _serde::__private::Err(
273 <__A::Error as _serde::de::Error>::missing_field(
274 "transitionInfoReferenceForTE",
275 ),
276 );
277 }
278 };
279 let m_toStateId = match m_toStateId {
280 _serde::__private::Some(__field) => __field,
281 _serde::__private::None => {
282 return _serde::__private::Err(
283 <__A::Error as _serde::de::Error>::missing_field(
284 "toStateId",
285 ),
286 );
287 }
288 };
289 _serde::__private::Ok(hkbStateMachineProspectiveTransitionInfo {
290 __ptr,
291 m_transitionInfoReference,
292 m_transitionInfoReferenceForTE,
293 m_toStateId,
294 })
295 }
296 #[allow(clippy::manual_unwrap_or_default)]
297 fn visit_struct<__A>(
298 self,
299 mut __map: __A,
300 ) -> _serde::__private::Result<Self::Value, __A::Error>
301 where
302 __A: _serde::de::MapAccess<'de>,
303 {
304 let mut m_transitionInfoReference: _serde::__private::Option<
305 hkbStateMachineTransitionInfoReference,
306 > = _serde::__private::None;
307 let mut m_transitionInfoReferenceForTE: _serde::__private::Option<
308 hkbStateMachineTransitionInfoReference,
309 > = _serde::__private::None;
310 let mut m_toStateId: _serde::__private::Option<i32> = _serde::__private::None;
311 while let _serde::__private::Some(__key) = {
312 __A::next_key::<__Field>(&mut __map)?
313 } {
314 match __key {
315 __Field::m_transitionInfoReference => {
316 #[cfg(
317 any(feature = "strict", feature = "ignore_duplicates")
318 )]
319 if _serde::__private::Option::is_some(
320 &m_transitionInfoReference,
321 ) {
322 #[cfg(feature = "ignore_duplicates")]
323 {
324 __A::skip_value(&mut __map)?;
325 continue;
326 }
327 #[cfg(feature = "strict")]
328 return _serde::__private::Err(
329 <__A::Error as _serde::de::Error>::duplicate_field(
330 "transitionInfoReference",
331 ),
332 );
333 }
334 m_transitionInfoReference = _serde::__private::Some(
335 match __A::next_value::<
336 hkbStateMachineTransitionInfoReference,
337 >(&mut __map) {
338 _serde::__private::Ok(__val) => __val,
339 _serde::__private::Err(__err) => {
340 return _serde::__private::Err(__err);
341 }
342 },
343 );
344 }
345 __Field::m_transitionInfoReferenceForTE => {
346 #[cfg(
347 any(feature = "strict", feature = "ignore_duplicates")
348 )]
349 if _serde::__private::Option::is_some(
350 &m_transitionInfoReferenceForTE,
351 ) {
352 #[cfg(feature = "ignore_duplicates")]
353 {
354 __A::skip_value(&mut __map)?;
355 continue;
356 }
357 #[cfg(feature = "strict")]
358 return _serde::__private::Err(
359 <__A::Error as _serde::de::Error>::duplicate_field(
360 "transitionInfoReferenceForTE",
361 ),
362 );
363 }
364 m_transitionInfoReferenceForTE = _serde::__private::Some(
365 match __A::next_value::<
366 hkbStateMachineTransitionInfoReference,
367 >(&mut __map) {
368 _serde::__private::Ok(__val) => __val,
369 _serde::__private::Err(__err) => {
370 return _serde::__private::Err(__err);
371 }
372 },
373 );
374 }
375 __Field::m_toStateId => {
376 #[cfg(
377 any(feature = "strict", feature = "ignore_duplicates")
378 )]
379 if _serde::__private::Option::is_some(&m_toStateId) {
380 #[cfg(feature = "ignore_duplicates")]
381 {
382 __A::skip_value(&mut __map)?;
383 continue;
384 }
385 #[cfg(feature = "strict")]
386 return _serde::__private::Err(
387 <__A::Error as _serde::de::Error>::duplicate_field(
388 "toStateId",
389 ),
390 );
391 }
392 m_toStateId = _serde::__private::Some(
393 match __A::next_value::<i32>(&mut __map) {
394 _serde::__private::Ok(__val) => __val,
395 _serde::__private::Err(__err) => {
396 return _serde::__private::Err(__err);
397 }
398 },
399 );
400 }
401 _ => __A::skip_value(&mut __map)?,
402 }
403 }
404 let m_transitionInfoReference = match m_transitionInfoReference {
405 _serde::__private::Some(__field) => __field,
406 _serde::__private::None => {
407 #[cfg(feature = "strict")]
408 return _serde::__private::Err(
409 <__A::Error as _serde::de::Error>::missing_field(
410 "transitionInfoReference",
411 ),
412 );
413 #[cfg(not(feature = "strict"))] Default::default()
414 }
415 };
416 let m_transitionInfoReferenceForTE = match m_transitionInfoReferenceForTE {
417 _serde::__private::Some(__field) => __field,
418 _serde::__private::None => {
419 #[cfg(feature = "strict")]
420 return _serde::__private::Err(
421 <__A::Error as _serde::de::Error>::missing_field(
422 "transitionInfoReferenceForTE",
423 ),
424 );
425 #[cfg(not(feature = "strict"))] Default::default()
426 }
427 };
428 let m_toStateId = match m_toStateId {
429 _serde::__private::Some(__field) => __field,
430 _serde::__private::None => {
431 #[cfg(feature = "strict")]
432 return _serde::__private::Err(
433 <__A::Error as _serde::de::Error>::missing_field(
434 "toStateId",
435 ),
436 );
437 #[cfg(not(feature = "strict"))] Default::default()
438 }
439 };
440 let __ptr = __A::class_ptr(&mut __map);
441 _serde::__private::Ok(hkbStateMachineProspectiveTransitionInfo {
442 __ptr,
443 m_transitionInfoReference,
444 m_transitionInfoReferenceForTE,
445 m_toStateId,
446 })
447 }
448 }
449 const FIELDS: &[&str] = &[
450 "transitionInfoReference",
451 "transitionInfoReferenceForTE",
452 "toStateId",
453 ];
454 _serde::Deserializer::deserialize_struct(
455 deserializer,
456 "hkbStateMachineProspectiveTransitionInfo",
457 FIELDS,
458 __hkbStateMachineProspectiveTransitionInfoVisitor {
459 marker: _serde::__private::PhantomData::<
460 hkbStateMachineProspectiveTransitionInfo,
461 >,
462 lifetime: _serde::__private::PhantomData,
463 },
464 )
465 }
466 }
467};