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