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