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