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