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