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