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 hkbSetNodePropertyCommand<'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 = "serde", serde(borrow))]
42 #[cfg_attr(feature = "json_schema", schemars(rename = "nodeName"))]
43 #[cfg_attr(feature = "serde", serde(rename = "nodeName"))]
44 pub m_nodeName: StringPtr<'a>,
45 #[cfg_attr(feature = "serde", serde(borrow))]
50 #[cfg_attr(feature = "json_schema", schemars(rename = "propertyName"))]
51 #[cfg_attr(feature = "serde", serde(rename = "propertyName"))]
52 pub m_propertyName: StringPtr<'a>,
53 #[cfg_attr(feature = "json_schema", schemars(rename = "propertyValue"))]
58 #[cfg_attr(feature = "serde", serde(rename = "propertyValue"))]
59 pub m_propertyValue: hkbVariableValue,
60 #[cfg_attr(feature = "json_schema", schemars(rename = "padding"))]
65 #[cfg_attr(feature = "serde", serde(rename = "padding"))]
66 pub m_padding: i32,
67}
68const _: () = {
69 use havok_serde as _serde;
70 impl<'a> _serde::HavokClass for hkbSetNodePropertyCommand<'a> {
71 #[inline]
72 fn name(&self) -> &'static str {
73 "hkbSetNodePropertyCommand"
74 }
75 #[inline]
76 fn signature(&self) -> _serde::__private::Signature {
77 _serde::__private::Signature::new(0xc5160b64)
78 }
79 #[allow(clippy::let_and_return, clippy::vec_init_then_push)]
80 fn deps_indexes(&self) -> Vec<usize> {
81 let mut v = Vec::new();
82 v.extend(self.m_propertyValue.deps_indexes());
83 v
84 }
85 }
86 impl<'a> _serde::Serialize for hkbSetNodePropertyCommand<'a> {
87 fn serialize<S>(&self, __serializer: S) -> Result<S::Ok, S::Error>
88 where
89 S: _serde::ser::Serializer,
90 {
91 let class_meta = self
92 .__ptr
93 .map(|name| (name, _serde::__private::Signature::new(0xc5160b64)));
94 let mut serializer = __serializer
95 .serialize_struct(
96 "hkbSetNodePropertyCommand",
97 class_meta,
98 (32u64, 48u64),
99 )?;
100 serializer.pad_field([0u8; 4usize].as_slice(), [0u8; 8usize].as_slice())?;
101 serializer.skip_field("memSizeAndFlags", &self.parent.m_memSizeAndFlags)?;
102 serializer.skip_field("referenceCount", &self.parent.m_referenceCount)?;
103 serializer.pad_field([0u8; 0usize].as_slice(), [0u8; 4usize].as_slice())?;
104 serializer.serialize_field("characterId", &self.m_characterId)?;
105 serializer.serialize_field("nodeName", &self.m_nodeName)?;
106 serializer.serialize_field("propertyName", &self.m_propertyName)?;
107 serializer.serialize_field("propertyValue", &self.m_propertyValue)?;
108 serializer.serialize_field("padding", &self.m_padding)?;
109 serializer.end()
110 }
111 }
112};
113#[doc(hidden)]
114#[allow(non_upper_case_globals, unused_attributes, unused_qualifications)]
115const _: () = {
116 use havok_serde as _serde;
117 #[automatically_derived]
118 impl<'de> _serde::Deserialize<'de> for hkbSetNodePropertyCommand<'de> {
119 fn deserialize<__D>(deserializer: __D) -> core::result::Result<Self, __D::Error>
120 where
121 __D: _serde::Deserializer<'de>,
122 {
123 #[allow(non_camel_case_types)]
124 enum __Field {
125 m_characterId,
126 m_nodeName,
127 m_propertyName,
128 m_propertyValue,
129 m_padding,
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 "characterId" => Ok(__Field::m_characterId),
154 "nodeName" => Ok(__Field::m_nodeName),
155 "propertyName" => Ok(__Field::m_propertyName),
156 "propertyValue" => Ok(__Field::m_propertyValue),
157 "padding" => Ok(__Field::m_padding),
158 _ => Ok(__Field::__ignore),
159 }
160 }
161 }
162 impl<'de> _serde::Deserialize<'de> for __Field {
163 #[inline]
164 fn deserialize<__D>(
165 __deserializer: __D,
166 ) -> core::result::Result<Self, __D::Error>
167 where
168 __D: _serde::Deserializer<'de>,
169 {
170 _serde::Deserializer::deserialize_key(__deserializer, __FieldVisitor)
171 }
172 }
173 struct __hkbSetNodePropertyCommandVisitor<'de> {
174 marker: _serde::__private::PhantomData<hkbSetNodePropertyCommand<'de>>,
175 lifetime: _serde::__private::PhantomData<&'de ()>,
176 }
177 #[allow(clippy::match_single_binding)]
178 #[allow(clippy::reversed_empty_ranges)]
179 #[allow(clippy::single_match)]
180 impl<'de> _serde::de::Visitor<'de>
181 for __hkbSetNodePropertyCommandVisitor<'de> {
182 type Value = hkbSetNodePropertyCommand<'de>;
183 fn expecting(
184 &self,
185 __formatter: &mut core::fmt::Formatter,
186 ) -> core::fmt::Result {
187 core::fmt::Formatter::write_str(
188 __formatter,
189 "struct hkbSetNodePropertyCommand",
190 )
191 }
192 fn visit_struct_for_bytes<__A>(
193 self,
194 mut __map: __A,
195 ) -> _serde::__private::Result<Self::Value, __A::Error>
196 where
197 __A: _serde::de::MapAccess<'de>,
198 {
199 let __ptr = __A::class_ptr(&mut __map);
200 let parent = __A::parent_value(&mut __map)?;
201 let mut m_characterId: _serde::__private::Option<u64> = _serde::__private::None;
202 let mut m_nodeName: _serde::__private::Option<StringPtr<'de>> = _serde::__private::None;
203 let mut m_propertyName: _serde::__private::Option<StringPtr<'de>> = _serde::__private::None;
204 let mut m_propertyValue: _serde::__private::Option<
205 hkbVariableValue,
206 > = _serde::__private::None;
207 let mut m_padding: _serde::__private::Option<i32> = _serde::__private::None;
208 for i in 0..5usize {
209 match i {
210 0usize => {
211 if _serde::__private::Option::is_some(&m_characterId) {
212 return _serde::__private::Err(
213 <__A::Error as _serde::de::Error>::duplicate_field(
214 "characterId",
215 ),
216 );
217 }
218 m_characterId = _serde::__private::Some(
219 match __A::next_value::<u64>(&mut __map) {
220 _serde::__private::Ok(__val) => __val,
221 _serde::__private::Err(__err) => {
222 return _serde::__private::Err(__err);
223 }
224 },
225 );
226 }
227 1usize => {
228 if _serde::__private::Option::is_some(&m_nodeName) {
229 return _serde::__private::Err(
230 <__A::Error as _serde::de::Error>::duplicate_field(
231 "nodeName",
232 ),
233 );
234 }
235 m_nodeName = _serde::__private::Some(
236 match __A::next_value::<StringPtr<'de>>(&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_propertyName) {
246 return _serde::__private::Err(
247 <__A::Error as _serde::de::Error>::duplicate_field(
248 "propertyName",
249 ),
250 );
251 }
252 m_propertyName = _serde::__private::Some(
253 match __A::next_value::<StringPtr<'de>>(&mut __map) {
254 _serde::__private::Ok(__val) => __val,
255 _serde::__private::Err(__err) => {
256 return _serde::__private::Err(__err);
257 }
258 },
259 );
260 }
261 3usize => {
262 if _serde::__private::Option::is_some(&m_propertyValue) {
263 return _serde::__private::Err(
264 <__A::Error as _serde::de::Error>::duplicate_field(
265 "propertyValue",
266 ),
267 );
268 }
269 m_propertyValue = _serde::__private::Some(
270 match __A::next_value::<hkbVariableValue>(&mut __map) {
271 _serde::__private::Ok(__val) => __val,
272 _serde::__private::Err(__err) => {
273 return _serde::__private::Err(__err);
274 }
275 },
276 );
277 }
278 4usize => {
279 if _serde::__private::Option::is_some(&m_padding) {
280 return _serde::__private::Err(
281 <__A::Error as _serde::de::Error>::duplicate_field(
282 "padding",
283 ),
284 );
285 }
286 m_padding = _serde::__private::Some(
287 match __A::next_value::<i32>(&mut __map) {
288 _serde::__private::Ok(__val) => __val,
289 _serde::__private::Err(__err) => {
290 return _serde::__private::Err(__err);
291 }
292 },
293 );
294 }
295 _ => {}
296 }
297 }
298 let m_characterId = match m_characterId {
299 _serde::__private::Some(__field) => __field,
300 _serde::__private::None => {
301 return _serde::__private::Err(
302 <__A::Error as _serde::de::Error>::missing_field(
303 "characterId",
304 ),
305 );
306 }
307 };
308 let m_nodeName = match m_nodeName {
309 _serde::__private::Some(__field) => __field,
310 _serde::__private::None => {
311 return _serde::__private::Err(
312 <__A::Error as _serde::de::Error>::missing_field("nodeName"),
313 );
314 }
315 };
316 let m_propertyName = match m_propertyName {
317 _serde::__private::Some(__field) => __field,
318 _serde::__private::None => {
319 return _serde::__private::Err(
320 <__A::Error as _serde::de::Error>::missing_field(
321 "propertyName",
322 ),
323 );
324 }
325 };
326 let m_propertyValue = match m_propertyValue {
327 _serde::__private::Some(__field) => __field,
328 _serde::__private::None => {
329 return _serde::__private::Err(
330 <__A::Error as _serde::de::Error>::missing_field(
331 "propertyValue",
332 ),
333 );
334 }
335 };
336 let m_padding = match m_padding {
337 _serde::__private::Some(__field) => __field,
338 _serde::__private::None => {
339 return _serde::__private::Err(
340 <__A::Error as _serde::de::Error>::missing_field("padding"),
341 );
342 }
343 };
344 _serde::__private::Ok(hkbSetNodePropertyCommand {
345 __ptr,
346 parent,
347 m_characterId,
348 m_nodeName,
349 m_propertyName,
350 m_propertyValue,
351 m_padding,
352 })
353 }
354 #[allow(clippy::manual_unwrap_or_default)]
355 fn visit_struct<__A>(
356 self,
357 mut __map: __A,
358 ) -> _serde::__private::Result<Self::Value, __A::Error>
359 where
360 __A: _serde::de::MapAccess<'de>,
361 {
362 let mut m_characterId: _serde::__private::Option<u64> = _serde::__private::None;
363 let mut m_nodeName: _serde::__private::Option<StringPtr<'de>> = _serde::__private::None;
364 let mut m_propertyName: _serde::__private::Option<StringPtr<'de>> = _serde::__private::None;
365 let mut m_propertyValue: _serde::__private::Option<
366 hkbVariableValue,
367 > = _serde::__private::None;
368 let mut m_padding: _serde::__private::Option<i32> = _serde::__private::None;
369 while let _serde::__private::Some(__key) = {
370 __A::next_key::<__Field>(&mut __map)?
371 } {
372 match __key {
373 __Field::m_characterId => {
374 #[cfg(
375 any(feature = "strict", feature = "ignore_duplicates")
376 )]
377 if _serde::__private::Option::is_some(&m_characterId) {
378 #[cfg(feature = "ignore_duplicates")]
379 {
380 __A::skip_value(&mut __map)?;
381 continue;
382 }
383 #[cfg(feature = "strict")]
384 return _serde::__private::Err(
385 <__A::Error as _serde::de::Error>::duplicate_field(
386 "characterId",
387 ),
388 );
389 }
390 m_characterId = _serde::__private::Some(
391 match __A::next_value::<u64>(&mut __map) {
392 _serde::__private::Ok(__val) => __val,
393 _serde::__private::Err(__err) => {
394 return _serde::__private::Err(__err);
395 }
396 },
397 );
398 }
399 __Field::m_nodeName => {
400 #[cfg(
401 any(feature = "strict", feature = "ignore_duplicates")
402 )]
403 if _serde::__private::Option::is_some(&m_nodeName) {
404 #[cfg(feature = "ignore_duplicates")]
405 {
406 __A::skip_value(&mut __map)?;
407 continue;
408 }
409 #[cfg(feature = "strict")]
410 return _serde::__private::Err(
411 <__A::Error as _serde::de::Error>::duplicate_field(
412 "nodeName",
413 ),
414 );
415 }
416 m_nodeName = _serde::__private::Some(
417 match __A::next_value::<StringPtr<'de>>(&mut __map) {
418 _serde::__private::Ok(__val) => __val,
419 _serde::__private::Err(__err) => {
420 return _serde::__private::Err(__err);
421 }
422 },
423 );
424 }
425 __Field::m_propertyName => {
426 #[cfg(
427 any(feature = "strict", feature = "ignore_duplicates")
428 )]
429 if _serde::__private::Option::is_some(&m_propertyName) {
430 #[cfg(feature = "ignore_duplicates")]
431 {
432 __A::skip_value(&mut __map)?;
433 continue;
434 }
435 #[cfg(feature = "strict")]
436 return _serde::__private::Err(
437 <__A::Error as _serde::de::Error>::duplicate_field(
438 "propertyName",
439 ),
440 );
441 }
442 m_propertyName = _serde::__private::Some(
443 match __A::next_value::<StringPtr<'de>>(&mut __map) {
444 _serde::__private::Ok(__val) => __val,
445 _serde::__private::Err(__err) => {
446 return _serde::__private::Err(__err);
447 }
448 },
449 );
450 }
451 __Field::m_propertyValue => {
452 #[cfg(
453 any(feature = "strict", feature = "ignore_duplicates")
454 )]
455 if _serde::__private::Option::is_some(&m_propertyValue) {
456 #[cfg(feature = "ignore_duplicates")]
457 {
458 __A::skip_value(&mut __map)?;
459 continue;
460 }
461 #[cfg(feature = "strict")]
462 return _serde::__private::Err(
463 <__A::Error as _serde::de::Error>::duplicate_field(
464 "propertyValue",
465 ),
466 );
467 }
468 m_propertyValue = _serde::__private::Some(
469 match __A::next_value::<hkbVariableValue>(&mut __map) {
470 _serde::__private::Ok(__val) => __val,
471 _serde::__private::Err(__err) => {
472 return _serde::__private::Err(__err);
473 }
474 },
475 );
476 }
477 __Field::m_padding => {
478 #[cfg(
479 any(feature = "strict", feature = "ignore_duplicates")
480 )]
481 if _serde::__private::Option::is_some(&m_padding) {
482 #[cfg(feature = "ignore_duplicates")]
483 {
484 __A::skip_value(&mut __map)?;
485 continue;
486 }
487 #[cfg(feature = "strict")]
488 return _serde::__private::Err(
489 <__A::Error as _serde::de::Error>::duplicate_field(
490 "padding",
491 ),
492 );
493 }
494 m_padding = _serde::__private::Some(
495 match __A::next_value::<i32>(&mut __map) {
496 _serde::__private::Ok(__val) => __val,
497 _serde::__private::Err(__err) => {
498 return _serde::__private::Err(__err);
499 }
500 },
501 );
502 }
503 _ => __A::skip_value(&mut __map)?,
504 }
505 }
506 let m_characterId = match m_characterId {
507 _serde::__private::Some(__field) => __field,
508 _serde::__private::None => {
509 #[cfg(feature = "strict")]
510 return _serde::__private::Err(
511 <__A::Error as _serde::de::Error>::missing_field(
512 "characterId",
513 ),
514 );
515 #[cfg(not(feature = "strict"))] Default::default()
516 }
517 };
518 let m_nodeName = match m_nodeName {
519 _serde::__private::Some(__field) => __field,
520 _serde::__private::None => {
521 #[cfg(feature = "strict")]
522 return _serde::__private::Err(
523 <__A::Error as _serde::de::Error>::missing_field("nodeName"),
524 );
525 #[cfg(not(feature = "strict"))] Default::default()
526 }
527 };
528 let m_propertyName = match m_propertyName {
529 _serde::__private::Some(__field) => __field,
530 _serde::__private::None => {
531 #[cfg(feature = "strict")]
532 return _serde::__private::Err(
533 <__A::Error as _serde::de::Error>::missing_field(
534 "propertyName",
535 ),
536 );
537 #[cfg(not(feature = "strict"))] Default::default()
538 }
539 };
540 let m_propertyValue = match m_propertyValue {
541 _serde::__private::Some(__field) => __field,
542 _serde::__private::None => {
543 #[cfg(feature = "strict")]
544 return _serde::__private::Err(
545 <__A::Error as _serde::de::Error>::missing_field(
546 "propertyValue",
547 ),
548 );
549 #[cfg(not(feature = "strict"))] Default::default()
550 }
551 };
552 let m_padding = match m_padding {
553 _serde::__private::Some(__field) => __field,
554 _serde::__private::None => {
555 #[cfg(feature = "strict")]
556 return _serde::__private::Err(
557 <__A::Error as _serde::de::Error>::missing_field("padding"),
558 );
559 #[cfg(not(feature = "strict"))] Default::default()
560 }
561 };
562 let __ptr = None;
563 let parent = hkBaseObject { __ptr };
564 let parent = hkReferencedObject {
565 __ptr,
566 parent,
567 ..Default::default()
568 };
569 let __ptr = __A::class_ptr(&mut __map);
570 _serde::__private::Ok(hkbSetNodePropertyCommand {
571 __ptr,
572 parent,
573 m_characterId,
574 m_nodeName,
575 m_propertyName,
576 m_propertyValue,
577 m_padding,
578 })
579 }
580 }
581 const FIELDS: &[&str] = &[
582 "characterId",
583 "nodeName",
584 "propertyName",
585 "propertyValue",
586 "padding",
587 ];
588 _serde::Deserializer::deserialize_struct(
589 deserializer,
590 "hkbSetNodePropertyCommand",
591 FIELDS,
592 __hkbSetNodePropertyCommandVisitor {
593 marker: _serde::__private::PhantomData::<hkbSetNodePropertyCommand>,
594 lifetime: _serde::__private::PhantomData,
595 },
596 )
597 }
598 }
599};