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