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